CEETRON Envision for Web [EnvisionWeb]

Version: 1.4.0+d3109217

The most up-to-date online version of the documentation can be found here:

https://docs.techsoft3d.com/ceetron/latest/envision-web/index.html

INTRODUCTION

Want to build a 3D visualization solution for your cloud-based CAE application? Something that can be delivered in months, not years. Something with the performance of a desktop application? Something browser-based (and no plugin, no installation)? CEETRON Envision for Web is a set of software components for creating cloud-based high-performance visualization solutions for cloud-based solvers and CAE model repositories.

alt text

COMPONENTS

Global (cee): Main component with general classes like Viewer, View, Model, Overlay, etc. Also has base classes like Color3, Color4, Vec3, Mat4, Ray. Use these classes in combination with one or more of the components below to create an application.
Remote Model (cee.ug): The RemoteModel supports a full post processing session with a CAE model on a remote server. The CAE model with it's results is kept on the server and only the data needed for displaying the model (triangles, texture coordinates, etc) are streamed using 3D Progressive Object Streaming to the client. Handles FEA and CFD models, and has features like isovolumes, particle traces, cutting planes (all computed on the server). Cannot be used without a UgServer, and the server requires a unique (sticky) session per concurrent user.
Constant Remote Model (cee.cug): The ConstantRemoteModel supports an efficient and scalable streaming of pre-defined CAE model configurations. The server is a stateless REST API based server that has very low resource usage on the server side and is easy to load balance. The streaming also starts immediately when a model is opened, no matter the size of the model. Similar to RemoteModel, it utilizes 3D Progressive Object Streaming to the client. The model needs to be converted into a CUG database format before it can be streamed. This is done with the included CugComposer command line utility. The ConstantRemoteModel is used in the viewer on Ceetron Cloud.
Unstruct Surface Grid (cee.usg): Client side (in browser) FEA model for surface elements. Suited for any size FEA surface models (as long as the part count is <10k). Supports any kind of surface elements (1..N nodes per element). The model is defined by elements and nodes, and support scalar, vector, displacement and transformation results. The model has support for any number of states (time steps). Supports calculation of element-aware surface normals and element mesh lines as well as model outline. It also supports ray intersection at the element level. The model features all draw styles (surface, surface mesh, outline, lines, points, transparent surface). The model handles only one result of each type at any given time, so you will have to handle the result database in application code. Components for implementing a stateless server for progressive streaming of models as well as a reference implementation will soon be available.
Geometry (cee.geo): Client side (in browser) model suited for models with only geometry or simple scalar results. This modes does rebatching of parts and has an optimize renderer capable of handling >300k parts. This is the only CEETRON Envision model with this capability. Can be used with the server/GeoServer for 3D Progressive Object Streaming of models. This stateless, REST API based server comes with support for file and Redis based storage, and can also be extended with other DataStores.
Markup (cee.mrk): Markup model with support for rendering labels and more simple geometry. Useful for creating annotations and other markup of the 3d model.
Utilities (cee.utils): Various helper classes for the components above.

BUILD YOUR FIRST APP WITH CEETRON ENVISION FOR WEB

The Examples/BuildYourFirstApp folder contains 4 simple examples showcasing how to get started with the 3 main components of Envision. This is a good place to start to see how to use Envision. The examples are:

Hello Envision : Minimal Envision app using the geometry model GeometryModel to draw two simple objects.
Viewer: A simple demonstration on how to use the ConstantRemoteModel to show pre-defined models in a scalable way.
FirstPostProcessor: A very simple interactive CAE post-processor showcasing the RemoteModel.
FeatureExtraction: The second example featuring the RemoteModel. This time with a focus on cutting planes, isovolumes and particle traces.

To setup your own server and dig more info the RemoteModel, see the "SERVER FOR REMOTE MODEL" chapter below.

DISTRIBUTION CONTENT

client

The client part of CEETRON Envision.
- CeeEnvisionWebComponents.js: A minified version of the Envision for Web client.
- CeeEnvisionWebComponents.d.ts: TypeScript declaration file for all the components
server/UgServer

The ready-to-run server for remote CAE models (RemoteModel) in the ug component. The server consists of:
- The CeeUgServer.node Node.js Add-on for reading, managing and creating visualizations of CAE data. You should use the Add-on appropriate for your license, see the "License" section below.
- JavaScript files implementing the WebSocket server.
- package.json file describing the dependencies (of which there is just one - Socket.io).
The server has an optional REST API for adding models and for querying models. These options can be enabled with environment variables.

See the "Getting Started" section below for instructions on how to start the server.

Docker version: https://hub.docker.com/r/ceetron/envision-ug-server/
server/CugServer

A high performance stateless REST-API based server for the ConstantRemoteModel with very low server resource usage.

Models needs to be converted into a CUG database format before they can be streamed. See (cee.cug) for more info.

Docker version:

server/GeoServer

A high performance stateless REST-API based geometry server with very low server resource usage. The server is written purely in TypeScript and only requires Node.js to run (no native Add-on), and there is no web-socket dependency.

From the client, the GeometryModelRemoteLoader can be used to progressively populate a GeometryModel. The loader supports an optional low res GeometryModel that can be used to show a low res version of the model while the full res version is being downloaded. The DemoAppGeo example application includes a demonstration of this.

The server uses a generic DataStore, and comes with implementations of a Redis based and File based DataStore.

Docker version: https://hub.docker.com/r/ceetron/envision-geo-server/
Documentation

Detailed documentation for each class and function in CEETRON Envision for Web. Open Documentation/index.html to start browsing the documentation. You can also access the latest documentation at https://ceetron.com/docs/CloudComponents/index.html.
Examples

Example client applications demonstrating how to use CEETRON Envision for Web:
- CloudPost: A post-processor powered by Envision. Written in TypeScript, but JavaScript files are also included. Uses JQueryUI
- Angular: A simple post-processor powered by Envision using Angular as the UI toolkit.
- React: A simple post-processor powered by Envision using Angular as the UI toolkit.
- Svelte: A simple post-processor powered by Envision using Angular as the UI toolkit.
- Vue: A simple post-processor powered by Envision using Angular as the UI toolkit.
- DemoAppUg: An app showcasing some of the features of the Remote Model. Written in JavaScript, but JavaScript files are also included.
- DemoAppCug: An app demonstrating the constant remote model. Written in TypeScript, but JavaScript files are also included.
- DemoAppGeo: An app demonstrating some of the features of the Envision geo module. Written in TypeScript, but JavaScript files are also included.
- DemoAppUsg: An app showcasing some of the features of the Unstruct Surface Grid client side FEA model. Written in JavaScript, but JavaScript files are also included.
- MinimalGeoTypeScript: A minimal example of how to get Envision geo module up and running using TypeScript.
- MinimalUg: A minimal example of how to get Envision up and running using JavaScript.
- MinimalUgTypeScript: A minimal example of how to get Envision up and running using TypeScript.
- MinimalUgTypeScriptGlobal: A minimal TypeScript example of how to import Envision using a global script reference and a global variable definition.
- Usg_RemoteMonitoring: An app demonstrating streaming/monitoring of a live feed of simulation results.
- Usg_RemotePlayback: An app demonstrating animation playback of a FEA model with multiple states.
  
  Docker version of examples: https://hub.docker.com/r/ceetron/envision-examples/
  
  A more complete example, Analyzer Cloud, can be found at https://analyzer.ceetron.com. This is a web based post-processor that uses CEETRON Envision for Web. You can try this with your own data by using Docker: https://hub.docker.com/r/ceetron/analyzer-cloud
TestModels

A few VTFx test models used by the example apps.

SUPPORTED FILE FORMATS (RemoteModel)

The UgServer supports reading of the following formats out of the box:

VTFx and VTF (*.vtfx and *.vtf)
VTU/VTM/PVD VTK UnstructuredGrid) (*.vtu, *.vtm, *.pvd)
STL files (*.stl)

If this satisfies your requirements, you can use the 'CeeUgServer_noImportCae.node' add-on. This add-on has fewer dependencies (only TBB). See how to do so in the 'Getting Started' section below.

If, however, you need support for further formats, you must use the 'CeeUgServer.node' add-on (default). This will require a license with the ImportCAE option (see below for licensing information) to access the following formats:

Abaqus (*.fil)
ABAQUS Input Interface (*.inp)
ABAQUS Odb (*.odb) (see below)
ANSYS Input Interface (*.cdb)
ANSYS (.rst;*.rth;.rfl)
CGNS (*.cgns)
Ensight (*.case)
Fluent (.cas/.dat)
Femap (*.neu)
Ideas UNV (*.unv)
LSDYNA Keyword Interface (*.k)
LS-DYNA State Database Interface
NASTRAN (*.op2)
NASTRAN (*.dat)
OpenFOAM (*.foam)

Abaqus ODB Interface limitations

Due to a severe limitation in the official Abaqus ODB API, the server will run all Abaqus .odb file access in the main thread. This will block the server for any other requests while the file is being accessed. This should be taken into consideration when deploying a solution using the Abaqus ODB reader.

DATA PROVIDER PLUGINS (RemoteModel)

The UgServer supports dynamic loading of Data Provider Plugins. A Data Provider acts as a provider of data to the server (e.g. a file reader), allowing users of RemoteModel to create their own in-house file readers with the same ease of use and performance as the built-in readers.

To use Data Providers with the UgServer, define the CEW_UG_DATA_PROVIDER_FOLDER environment variable to point to the folder containing the data provider plugins. The UgServer will load all data providers in the specified folder.

Note that the plugins must be named after the following naming conversion:

   cdp_{PROVIDER_NAME}.[dll|so|dylib]

Example:

   cdp_MyDataProvider.dll (Windows), cdp_MyDataProvider.so (Linux)

To create your own data provider, download the "Ceetron Data Provider Framework" from ceetron.com. This framework is free to download and use, and is provided as source code so you can compile with your favorite compiler and settings.

LICENSE

You need a valid license to run the UgServer. A license can be generated in the Tech Soft 3D Developer Zone: https://developer.techsoft3d.com/ Please contact support@ceetron.com if you have any issues getting the license to work.

The license code (long string) need to be specified by calling ugServer.setLicenseCode(myCode) in server/UgServer/Main.js, as described in the "Getting Started" section below.

Licenses can be purchased with or without the ImportCAE option. This option provides support for additional file formats (see the "Supported File Formats" section above).

The server can be run used without a license, but then only the provided demo models will work.

TERMS & CONDITIONS

By using this software, you agree to the Terms & Conditions for use of Ceetron Software as described in https://ceetron.com/licenses/developer-terms-and-conditions

SERVER FOR REMOTE MODEL (UgServer)

Getting started with RemoteModel (interactive post processing of CAE Models)

Prerequisites for the CAE server:

Ubuntu 16.04 or newer / Microsoft Windows 7 (64bit) or newer / MacOS High Sierra (10.13) or newer
Node.js 8.6 (64 bit) or later. This can be downloaded from https://nodejs.org.

Note: You can also run the server with Docker on any platform. See https://hub.docker.com/r/ceetron/envision-ug-server/ for more information.

Overview of the Remote Model architecture: alt text

Download and extract 'CEETRON Envision for Web' distribution archive from the Tech Soft 3D Developer Zone: https://developer.techsoft3d.com/
Specify your license, either by modifying server/UgServer/Main.js to specify your license code:
```
     ugServer.setLicenseCode(myCode);
```
or by copying the hoops_license.h file downloaded from the developer zone into the server/UgServer folder, or by specifying the CEW_TECH_SOFT_LICENSE_FILE environment variable to point to the hoops_license.h.
With a terminal prompt, go to the 'server/UgServer' folder inside the distribution.
Execute the following command to fetch UgServer's single dependency, Sockets.io.
```
 > npm install
```
Start the server using npm:

Start the server with the appropriate command for your platform:
```
 > npm run startLinux
 > npm run startWin
 > npm run startMac
```
Note: If you want to use the 'CeeUgServer_noImportCae.node' add-on, set the CEW_UG_DISABLE_IMPORT_CAE to 1 (e.g. export CEW_UG_DISABLE_IMPORT_CAE=1). This will load the CeeUgServer_noImportCae.node which do not have a dependency to e.g. Abaqus libraries.

Node will then run Main.js, and the server will start on port 8998. The port can easily be changed in Main.js or by setting the PORT environment variable.

Windows note:
If you are having trouble launching the server on a Windows system, you may have to install additional C++ runtime libraries, these can be downloaded from https://aka.ms/vs/17/release/vc_redist.x64.exe.

You can verify that the server is running by opening http://localhost:8998 in a browser. You should then see a message like this

    Ceetron Cloud Server is alive
    Server ver: 2.2.0-5d8ff466 (add-on: 2.2.0-5d8ff466)
    Node.js ver: v8.9.2 (linux|x64)

We have included a simple http server for hosting the example web apps. To start the http server, go to the Examples/HttpServer folder and run:
```
 > npm install
```
Then start the server by running:
```
 > npm start
```
This will start the server on port 8000. This can be changed by the PORT environment variable or editing the HttpServer.js file.

Open http://localhost:8000 in your browser and you should see a welcome page for the example web apps.

You can also run the web apps by opening the corresponding index.html page (e.g. Examples/CloudPost/index.html).

If you are running the example apps and the UgServer on two different machines, you will have to modify the example app code to use the correct IP address for the UgServer server. Just replace vizServerUrl with the full URL to the UgServer in the line below:
```
var mySocket = io(vizServerUrl, {reconnection:false});
```
You might want to modify the modelFileFromKey() method in the Main.js file to provide proper model key to file path translation.
Please refer to the documentation to learn more about CEETRON Envision for Web. The central classes are:
- CloudSession: Applications will typically create a single instance of CloudSession for managing viewers. It also handles the animationFrameCallback which is essential for Envision to update and control animations.
- Viewer: Handles user interaction (pan/rotate/zoom), picking and other view related functions.
- RemoteModel: The main class for interacting with the remote CAE model. Handles result selection, part settings and all feature extractions (cut/iso/particle trace). RemoteModel requires the presence of a running UgServer.
- GeometryModel: Implements a client-side model that can handle a large number of parts efficiently.

Logging in UgServer

The RemoteModel server (UgServer) supports logging to console and file in two different formats: Standard (more human readable) and JSON (for easy processing or consumption by e.g. Logstash).

The logging output of the RemoteModel server (UgServer) can be controlled via the following environment variables:

CEW_UG_LOG_CONSOLE_OUTPUT_TYPE: Format for console log. Possible values: "standard", "json", "none". Default: "standard".
CEW_UG_LOG_FILE_OUTPUT_TYPE: Format for console log. Possible values: "standard", "json", "none". Default: "json".
CEW_UG_LOG_FILENAME: If file output type is not NONE, use this to specify the name of the log file. Default: "c3_ug_server.log".
CEW_UG_LOG_LEVEL: Specify what to log. Possible values: 1: Error, 2: Warning, 3: Info, 4: Debug, 5: Full debug. A 3 will log Error, Info and Warning, but not any debug messages. This is default.

It is also possible to add {key,value} pairs to the log on the server side from the client. This could be useful to trace operations through your web app. See RemoteModel.setServerLogContextKeyValueArr() for more info.

On linux, logging of segmentation faults is now also added to help debugging situations where the server crashes.

Examples

The example apps in the Envision distribution can be tested online at: http://envision.ceetron.com/

For a more complete example of an app powered by CEETRON Envision for Web, feel free to try Ceetron Analyzer Cloud (https://analyzer.ceetron.com). Although still a work-in-progress, it offers many features that demonstrate the capabilities of Envision for Web.

The Ceetron CAE Sharing portal uses CEETRON Envision technology: https://cloud.ceetron.com

SUPPORT

If you have any bug reports, questions or comments, please contact us on https://techsoft3d.atlassian.net/servicedesk/customer/portals. You can also use support@ceetron.com.

Best regards

The CEETRON Envision Team

All Rights Reserved. No part of this documentation or the accompanying source code shall be reproduced, stored in a retrieval system or transmitted by any means without written permission from the publisher.

Trademarks

"CEETRON Envision for Web" is a trademark of Ceetron AS.

Website: https://ceetron.com/ceetron-cloud-components/

Support: Please contact us on https://techsoft3d.atlassian.net/servicedesk/customer/portals or use support@ceetron.com