CEETRON CLOUD COMPONENTS (C3)

Version: 3.6.1-418d7381

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 Cloud Components 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 CeeCloudServer, 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 C3 model with this capability. Can be used with the CeeCloudGeoServer 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 C3

The Examples/BuildYourFirstApp folder contains 4 simple examples showcasing how to get started with the 3 main components of C3: RemoteModel, ConstantRemoteModel and GeometryModel. This is a good place to start to see how to use C3. To setup your own server and dig more info the RemoteModel, see the chapter below.

DISTRIBUTION CONTENT

CeeCloudClientComponent

The client part of Ceetron Cloud Components.
- CeeCloudClientComponent.min.js: A minified version of the C3 client. Should be used in production environments.
- CeeCloudClientComponent.js: A non-minified version of the C3 client unsuitable for production environments. Useful for debugging.
- CeeCloudClientComponent.d.ts: TypeScript declaration file.
CeeCloudServer

The ready-to-run server for remote CAE models (RemoteModel) in the ug component. The server consists of:
- The CeeCloud.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/c3-server/
CeeCloudGeoServer

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/c3-geo-server/
Documentation

Detailed documentation for each class and function in Ceetron Cloud Components. 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 Cloud Components:
- CloudPost: A simple post-processor powered by C3. Written in TypeScript, but JavaScript files are also included.
- DemoAppGeo: An app demonstrating some of the features of the C3 geo module. Written in TypeScript, but JavaScript files are also included.
- DemoAppUg: An app showcasing some of the features of the Remote Model. Written in JavaScript, 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 C3 geo module up and running using TypeScript.
- MinimalUg: A minimal example of how to get C3 up and running using JavaScript.
- MinimalUgTypeScript: A minimal example of how to get C3 up and running using TypeScript.
- MinimalUgTypeScriptGlobal: A minimal TypeScript example of how to import C3 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/c3-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 Cloud Components. 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 CeeCloudServer 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 'CeeCloud_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 'CeeCloud.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 CeeCloudServer 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 CeeCloudServer, define the C3_UG_DATA_PROVIDER_FOLDER environment variable to point to the folder containing the data provider plugins. The CeeCloudServer 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 CeeCloudServer. A free evaluation key can be downloaded from https://ceetron.com/developer-zone/download. Please contact support@ceetron.com if you have any issues getting the license to work.

The license keys (KeyA and KeyB) need to be specified by calling ceecloudserver.setLicenseKey(keyA, keyB) in CeeCloudServer/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).

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

GETTING STARTED WITH REMOTE MODELS (CAE MODELS)

Prerequisites for the CAE server:

Ubuntu 14.04 or newer / Microsoft Windows 7 (64bit) or newer / MacOS Sierra (10.12) or newer
Node.js 8.x 64 bit (note: the LTS version (8.x), not the latest version (9.x)). 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/c3-server/ for more information.

Overview of the Remote Model architecture: alt text

Download and extract the 'Cloud Components' distribution archive from https://ceetron.com/developer-zone-downloads/
Specify your license, either by
- setting the CEETRON_CLOUD_COMPONENTS_LICENSE_KEY_A and CEETRON_CLOUD_COMPONENTS_LICENSE_KEY_B environment variables,
- or modifying CeeCloudServer/Main.js to specify your license code:
```
  ceecloudserver.setLicenseKey(keyA, keyB);
```
With a terminal prompt, go to the 'CeeCloudServer' folder inside the distribution.
Execute the following command to fetch CeeCloudServers'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 'CeeCloud_noImportCae.node' add-on, set the C3_UG_DISABLE_IMPORT_CAE to 1 (e.g. export C3_UG_DISABLE_IMPORT_CAE=1). This will load the CeeCloud_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. This can be done by running the included vcredist_x64.exe installer located in CeeCloudServer/bin/win.

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 CeeCloudServer on two different machines, you will have to modify the example app code to use the correct IP address for the CeeCloudServer server. Just replace vizServerUrl with the full URL to the CeeCloudServer in the line below:
```
var mySocket = io.connect(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 Cloud Components. 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 C3 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 CeeCloudServer.
- GeometryModel: Implements a client-side model that can handle a large number of parts efficiently.

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

For a more complete example of an app powered by Ceetron Cloud Components, 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 C3.

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

SUPPORT

If you have any bug reports, questions or comments, please contact us on support@ceetron.com.

Best regards

The Ceetron Cloud Team

https://ceetron.com

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.

Support: support@ceetron.com

Ceetron Cloud Components