Version: 4.5.0-ed466b6f
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.
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.
The Examples/BuildYourFirstApp folder contains 4 simple examples showcasing how to get started with the 3 main components of C3. This is a good place to start to see how to use C3. The examples are:
To setup your own server and dig more info the RemoteModel, see the "SERVER FOR REMOTE MODEL" chapter below.
CeeCloudClientComponent
The client part of Ceetron Cloud Components.
CeeCloudServer
The ready-to-run server for remote CAE models (RemoteModel) in the ug component. The server consists of:
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.
The CeeCloudServer supports reading of the following formats out of the box:
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 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.
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.
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).
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
Prerequisites for the CAE server:
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:
Download and extract the 'Cloud Components' distribution archive from https://ceetron.com/developer-zone-downloads/
Specify your license, either by
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(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:
The RemoteModel server (CeeCloudServer) 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 (CeeCloudServer) can be controlled via the following environment variables:
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.
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
If you have any bug reports, questions or comments, please contact us on support@ceetron.com.
Best regards
The Ceetron Cloud Team
Copyright © 2021 by Ceetron AS
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.
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.
Ceetron Cloud Components is a trademark of Ceetron AS.
Ceetron AS, Innherredsveien 7, N-7014 Trondheim, NORWAY
Website: https://ceetron.com/ceetron-cloud-components/
Support: support@ceetron.com
Generated using TypeDoc