RemoteModel

class cee.ug.RemoteModel()

A remote server CAE model that can be displayed in the client viewer.

The RemoteModel is the controller of the visualization of the CAE model. Using this class you can specify which results to show on the model, set part settings as well as create cutting planes, isosurfaces, isovolumes and particle traces.

Use openModel to open a CAE model residing on the server. Once the optional callback passed to openModel is called, the ModelDirectory will have been populated and you can configure the initial view of the model. If a callback is not provided to openModel then the first state is shown.

Example: Minimal app, open default model on server:

var mySocket = io('http://localhost:8998');
var canvas = document.getElementById("myGlCanvas");

mySession = new cee.CloudSession();

myViewer = mySession.addViewer(canvas);
if (!myViewer) {
    return alert("No WebGL support");
}

myModel = new cee.ug.RemoteModel(mySocket);
var myView = myViewer.addView();
myView.addModel(myModel);

myModel.openModel("");

function myAnimationFrameCallback(highResTimestamp) {
    mySession.handleAnimationFrameCallback(highResTimestamp);
    requestAnimationFrame(myAnimationFrameCallback);
}

requestAnimationFrame(myAnimationFrameCallback);

The ModelSpec is the object you use to specify what to show in the remote model. Here you set which state(s) and results (scalar, vector, displacements) to display. You can setup a state animation by setting ModelSpec.stateIdArray, or setup a mode shape animation with ModelSpec.modeShapeFrameCount and ModelSpec.modeShapeAnimationType. Animation is controlled by the Animation class which can be accessed with animation.

You can access PartSettings objects with getPartSettingsById and use them to set various part attributes such visibility, color, opacity and draw style.

You can control how results are rendered with ScalarSettings, VectorSettings and DisplacementSettings objects, which can be accessed with getScalarSettingsById, getVectorSettingsById and getDisplacementSettingsById respectively.

For volumetric models, you can add any number of cutting plane, isosurface, isovolume and particle trace group objects to gain insight into the result distribution (e.g. flow field) within the model. The settings of these items can be controlled with the CuttingPlane, Isosurface, Isovolume, and ParticleTraceGroup objects. Use getCuttingPlaneById, getIsosurfaceById, getIsovolumeById and getParticleTraceGroupById to access such objects.

Picking is also done in the RemoteModel. Use rayIntersect to perform picking on the remote server model. This method takes a callback which is called when the picking result is available.

See the example in Examples/BuildYourFirstApp/3-FirstPostProcessor and 4-FeatureExtraction for how to use the RemoteModel

Example: Show the last state with the first scalar result and modify part settings

// Get the model and the model directory from the RemoteModel
var modelDir = myModel.modelDirectory;

// Show the last state in the analysis
var modelSpec = myModel.modelSpec;
modelSpec.stateIdArray =
      [modelDir.stateInfoArray[modelDir.stateInfoArray.length - 1].id];


// Show the first scalar as filled contours (if any)
if (modelDir.scalarResultArray.length > 0) {
    modelSpec.fringesResultId = modelDir.scalarResultArray[0].id;
}

// Modify the part settings: First part transparent, the rest with element mesh
for (var i = 0; i < myModel.partCount; ++i) {
    var partSettings = myModel.getPartSettingsAt(i);

    if (i == 0) {
        partSettings.drawStyle = cee.ug.DrawStyle.SURFACE;
        partSettings.opacity = 0.5;
    } else {
        partSettings.drawStyle = cee.ug.DrawStyle.SURFACE_MESH;
    }
}

This code sample produces the following image in the 3D Viewer:

None

Index

Constructors

Accessors

Methods

Constructors

cee.ug.RemoteModel.constructor()
RemoteModel(socketIOClient_socketInstance: any): RemoteModel

Creates a RemoteModel.

A socket connection to a live UgServer must be provided.

Example:

var mySocket = io('http://localhost:8998');
var myModel = new cee.ug.RemoteModel(mySocket, "");

Parameters

socketIOClient_socketInstance: any

Returns: RemoteModel

Accessors

cee.ug.RemoteModel.animation()
get animation(): Animation

The animation control for this RemoteModel.

Returns: Animation

cee.ug.RemoteModel.currentFrameIndex()
get currentFrameIndex(): number

The step to show in the view.

Use this property to specify a single step of the currently specified animation to show in the viewer. The given zero-based index must be between 0 and frameCount - 1.

Setting the current frame index will stop the animation if it is running.

Returns: number

set currentFrameIndex(frameIndex: number): void

Parameters

frameIndex: number

Returns: void

cee.ug.RemoteModel.currentStepText()
get currentStepText(): string

A description of the current step (e.g. time stamp, load case number, etc)

Returns: string

cee.ug.RemoteModel.cuttingPlaneCount()
get cuttingPlaneCount(): number

The number of cutting planes in the model.

Returns: number

cee.ug.RemoteModel.displacementSettingsCount()
get displacementSettingsCount(): number

The number of displacement settings in the model.

Returns: number

cee.ug.RemoteModel.frameCount()
get frameCount(): number

The number of steps/frames in the viewer.

The value of this property will be 1 if a model is loaded but contains no animation. If an animation has been setup then the value will be the number of animation steps.

Returns: number

cee.ug.RemoteModel.isosurfaceCount()
get isosurfaceCount(): number

The number of isosurfaces in the model.

Returns: number

cee.ug.RemoteModel.isovolumeCount()
get isovolumeCount(): number

The number of isovolumes in the model.

Returns: number

cee.ug.RemoteModel.mirrorSettings()
get mirrorSettings(): MirrorSettings

The mirror/symmetry settings for this RemoteModel

See MirrorSettings for more info.

Returns: MirrorSettings

cee.ug.RemoteModel.modelDirectory()
get modelDirectory(): ModelDirectory

The current ModelDirectory. This contains a table of contents of what is available to display in the analysis on the server (time steps, results, etc).

The ModelDirectory is fully available once the callback passed to openModel is called. Until then, this is an empty ModelDirectory with no data.

Returns: ModelDirectory

cee.ug.RemoteModel.modelSettings()
get modelSettings(): ModelSettings

The model settings for this RemoteModel

See ModelSettings for more info.

Returns: ModelSettings

cee.ug.RemoteModel.modelSpec()
get modelSpec(): ModelSpec

The specification of what to show in the remote model.

The ModelSpec controls what is shown in the RemoteModel (states, results, mode-shape animation).

The modelSpec is available once the callback passed to openModel is called. Until then, this is an empty ModelSpec with no data and accessing its setters will throw an error.

Returns: ModelSpec

cee.ug.RemoteModel.name()

Name of the model.

Mainly used for debugging.

get name(): string

Name of the geometry model.

Mainly used for debugging.

Returns: string

set name(name: string): void

Parameters

name: string

Returns: void

cee.ug.RemoteModel.partCount()
get partCount(): number

The number of parts in the model.

Returns: number

cee.ug.RemoteModel.particleTraceGroupCount()
get particleTraceGroupCount(): number

The number of particle trace groups in the model.

Returns: number

cee.ug.RemoteModel.scalarSettingsCount()
get scalarSettingsCount(): number

The number of scalar settings in the model.

Returns: number

cee.ug.RemoteModel.vectorSettingsCount()
get vectorSettingsCount(): number

The number of vector settings in the model.

Returns: number

Methods

cee.ug.RemoteModel.addCuttingPlane()
addCuttingPlane(): CuttingPlane

Adds a CuttingPlane to the remote model.

This will add a new cutting plane to the model. The cutting plane will be assigned an id by the model.

Note: Maximum number of clipping planes is 20

Returns: CuttingPlane

Returns the new CuttingPlane.
cee.ug.RemoteModel.addIsosurface()
addIsosurface(): Isosurface

Adds an Isosurface to the remote model.

This will add a new isosurface to the model. The isosurface will be assigned an id by the model. Returns null if the adding fails.

The default settings are:

Returns: Isosurface

Returns the new Isosurface.
cee.ug.RemoteModel.addIsovolume()
addIsovolume(): Isovolume

Adds an Isovolume to the remote model.

This will add a new isovolume to the model. The isovolume will be assigned an id by the model. Returns null if the adding fails.

The default settings are:

Returns: Isovolume

Returns the new Isovolume.
cee.ug.RemoteModel.addNextServerUpdateCompletedCallback()
addNextServerUpdateCompletedCallback(serverVisuaizationUpdateCompleteCallback: ServerUpdateCompletedCallback): void

Adds a one-shot callback that will be called once the next server visualization update is complete.

Whenever you change something in a RemoteModel, the pending changes will immediately be registered client-side, but will not be dispatched to the remote server until later. This server update typically happens in response to requestAnimationFrame() processing. The callback registered by this function will only be triggered once the next server update has been dispatched and has completed.

Please note that the callback will only be called once.

Parameters

serverVisuaizationUpdateCompleteCallback: ServerUpdateCompletedCallback

Returns: void

cee.ug.RemoteModel.addParticleTraceGroup()
addParticleTraceGroup(): ParticleTraceGroup

Adds a ParticleTraceGroup to the remote model.

This will add a new particle trace group to the model. The group will be assigned an id by the model.

Returns: ParticleTraceGroup

Returns the new ParticleTraceGroup.
cee.ug.RemoteModel.applyVTFxCase()
applyVTFxCase(caseId: number, applyVTFxCaseCompletedCallback: ApplyVTFxCaseCallback): void

Apply the VTFx case with the given id to the model.

The list of available VTFx cases with name and id can be found in ModelDirectory.vtfxCaseInfoArray

Parameters

caseId: number

applyVTFxCaseCompletedCallback: ApplyVTFxCaseCallback

Returns: void

cee.ug.RemoteModel.clientSideRayIntersect()
clientSideRayIntersect(ray: Ray): ClientSideHitItem

Performs a client-side (not on server) ray pick.

This might be faster or slower than a server pick request, depending on model size, latency, server capabilities and client capabilities. Note that this picking only considers visible surface geometry.

If something was hit, returns a ClientSideHitItem object containing information about the hit. Returns null if nothing was hit

Parameters

ray: Ray

Returns: ClientSideHitItem

cee.ug.RemoteModel.closeModel()
closeModel(): void

Closes the model, cleaning up on both the server and the client.

Returns: void

cee.ug.RemoteModel.createResultCalculator()
createResultCalculator(config: CreateResultCalculatorConfig, callback: CreateResultCalculatorCallback): void

Create a new result calculator result based on the given specification.

Result calculators are created with the Result Calculator Framework and loaded as .dll/.so/.dylib on the server. A calculator can be initialized with an initString. This string contains the configuration of the calculator (e.g. a mathematical expression).

Parameters

config: CreateResultCalculatorConfig

callback: CreateResultCalculatorCallback

An optional callback function triggered when the new result is available. From this method you can locate the newly created result in the model directory (using the calculatorId and resultIdString) and then e.g. apply it to the model.

Returns: void

Examples

// Basic usage
model.createResultCalculator({
    calculatorId: "MyCalculator",
    resultIdString: "MyResult",
    initString: "MyCustomExpression"
});

// With coordinate system
model.createResultCalculator({
    calculatorId: "MyCalculator",
    resultIdString: "MyResult",
    initString: "MyCustomExpression",
    coordSystemString: "type=cylindrical;origin=10.0,5.0,0.0;orientation=1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0"
});
cee.ug.RemoteModel.createTrianglePicker()
createTrianglePicker(view: View): TrianglePicker

Creates a TrianglePicker for this model and the specified view.

Returns null if no picker can be created, typically because WebGL resources have been exhausted.

See TrianglePicker for more information.

Parameters

view: View

Returns: TrianglePicker

cee.ug.RemoteModel.createVisibleObjectPicker()
createVisibleObjectPicker(view: View): VisibleObjectPicker

Creates a VisibleObjectPicker for this model and the specified view.

Returns null if no picker can be created, typically because WebGL resources have been exhausted.

This support class is used to get information about the visible items in the model. Given a rectangular region, this class can return the parts/objects that are currently visible in that region.

See VisibleObjectPicker for more information.

Parameters

view: View

Returns: VisibleObjectPicker

cee.ug.RemoteModel.deleteAllCuttingPlanes()
deleteAllCuttingPlanes(): void

Deletes all CuttingPlanes from the model.

Returns: void

cee.ug.RemoteModel.deleteAllIsosurfaces()
deleteAllIsosurfaces(): void

Deletes all Isosurfaces from the model.

Returns: void

cee.ug.RemoteModel.deleteAllIsovolumes()
deleteAllIsovolumes(): void

Delete all Isovolumes from the model.

Returns: void

cee.ug.RemoteModel.deleteAllParticleTraceGroups()
deleteAllParticleTraceGroups(): void

Deletes all ParticleTraceGroup from the model.

Returns: void

cee.ug.RemoteModel.deleteCuttingPlaneById()
deleteCuttingPlaneById(id: number): void

Deletes the CuttingPlane with the given id from the model.

Parameters

id: number

Returns: void

cee.ug.RemoteModel.deleteIsosurfaceById()
deleteIsosurfaceById(id: number): void

Deletes the Isosurface with the given id from the model.

Parameters

id: number

Returns: void

cee.ug.RemoteModel.deleteIsovolumeById()
deleteIsovolumeById(id: number): void

Deletes the Isovolume with the given id from the model.

Parameters

id: number

Returns: void

cee.ug.RemoteModel.deleteParticleTraceGroupById()
deleteParticleTraceGroupById(id: number): void

Deletes the ParticleTraceGroup with the given id from the model.

Parameters

id: number

Returns: void

cee.ug.RemoteModel.deleteResultCalculator()
deleteResultCalculator(calculatorId: string, resultIdString: string): void

Delete the result calculator with the given calculator id and result idString

Parameters

calculatorId: string

resultIdString: string

Returns: void

cee.ug.RemoteModel.enablePreloading()
enablePreloading(enable: boolean): void

Enables pre-loading of data.

If enabled, the server will stream all data specified in ModelSpec.stateIdArray to prepare the client for an animation or for stepping through the states.

If not enabled (default), data will only be streamed when needed (i.e. when a step is going to be displayed).

Parameters

enable: boolean

Returns: void

cee.ug.RemoteModel.executeDataSourceRequest()
executeDataSourceRequest(message: string, data: string, callback: DataSourceRequestCallback): void

Send a request to the server data source (Data Provider).

Note: Only one request can be in flight at any given time, so calling this method while a request is being processed will throw. To make sure you do not do that, use the isDataSourceRequestInProgress() method to check for any ongoing requests.

Parameters

message: string

data: string

callback: DataSourceRequestCallback

Returns: void

cee.ug.RemoteModel.getBoundingBox()
getBoundingBox(_options: ModelBoundingBoxOptions): BoundingBox

Returns the BoundingBox (in world coordinates) of the current contents of the RemoteModel

Note that currently this method does not support ModelBoundingBoxOptions so the returned bounding box will always be the “current” bounding box that accounts for visibility of parts/objects.

Parameters

Returns: BoundingBox

cee.ug.RemoteModel.getClientSidePartBoundingBox()
getClientSidePartBoundingBox(geometryIndex: number, partId: number): BoundingBox

Returns the BoundingBox (in world coordinates) of the given part in the current frame.

The bounding box returned is the bounding box of the specified part in the current frame, provided that the part is visible and present on the client.

Parameters

geometryIndex: number

partId: number

Returns: BoundingBox

cee.ug.RemoteModel.getCuttingPlaneArray()
getCuttingPlaneArray(): readonly  CuttingPlane[]

Returns all CuttingPlanes in the model.

Returns: readonly  CuttingPlane[]

cee.ug.RemoteModel.getCuttingPlaneAt()
getCuttingPlaneAt(index: number): CuttingPlane

Returns the CuttingPlane at the given index.

The index must be between 0 and cuttingPlaneCount - 1.

Use the returned object to modify the settings of the cutting plane.

Parameters

index: number

Returns: CuttingPlane

cee.ug.RemoteModel.getCuttingPlaneById()
getCuttingPlaneById(id: number): CuttingPlane

Returns the CuttingPlane with the given id, or null if no match is found.

Use the returned object to modify the settings of the cutting plane.

Parameters

id: number

Returns: CuttingPlane

cee.ug.RemoteModel.getDefaultCameraConfig()
getDefaultCameraConfig(): CameraConfig

Returns default camera configuration for this model if it exists

Returns: CameraConfig

cee.ug.RemoteModel.getDisplacementResultMaximumLength()
getDisplacementResultMaximumLength(resultId: number): number

Returns the maximum length for all items currently loaded in the RemoteModel for the given displacement result.

The resultId must refer to one of the displacement results in ModelDirectory.displacementResultArray.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getDisplacementResultMinimumLength()
getDisplacementResultMinimumLength(resultId: number): number

Returns the minimum length for all items currently loaded in the RemoteModel for the given displacement result.

The resultId must refer to one of the displacement results in ModelDirectory.displacementResultArray.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getDisplacementSettingsArray()
getDisplacementSettingsArray(): readonly  DisplacementSettings[]

Returns DisplacementSettings for all displacement results in the model.

Returns: readonly  DisplacementSettings[]

cee.ug.RemoteModel.getDisplacementSettingsAt()
getDisplacementSettingsAt(resultIndex: number): DisplacementSettings

Returns the DisplacementSettings for the result at the given index.

The index must be between 0 and displacementSettingsCount - 1.

Use the returned object to modify the settings of the displacement result.

Parameters

resultIndex: number

Returns: DisplacementSettings

cee.ug.RemoteModel.getDisplacementSettingsById()
getDisplacementSettingsById(resultId: number): DisplacementSettings

Returns the DisplacementSettings for the result with the given result id, or null if no match is found.

The resultId must refer to one of the displacement results in ModelDirectory.displacementResultArray.

Use the returned object to modify the settings of the displacement result.

Parameters

resultId: number

Returns: DisplacementSettings

cee.ug.RemoteModel.getElementCount()
getElementCount(frameIndex: number): number

Returns the total number of elements in the given frame

frameIndex must be <0..frameCount-1>

Parameters

frameIndex: number

Returns: number

Returns undefined if data for the frame has not yet been received.
cee.ug.RemoteModel.getIsosurfaceArray()
getIsosurfaceArray(): readonly  Isosurface[]

Returns all Isosurfaces in the model.

Returns: readonly  Isosurface[]

cee.ug.RemoteModel.getIsosurfaceAt()
getIsosurfaceAt(index: number): Isosurface

Returns the Isosurface at the given index.

The index must be between 0 and isosurfaceCount - 1.

Parameters

index: number

Returns: Isosurface

cee.ug.RemoteModel.getIsosurfaceById()
getIsosurfaceById(id: number): Isosurface

Returns the Isosurface with the given id, or null if no match is found.

Parameters

id: number

Returns: Isosurface

cee.ug.RemoteModel.getIsovolumeArray()
getIsovolumeArray(): readonly  Isovolume[]

Returns all the Isovolumes in the model.

Returns: readonly  Isovolume[]

cee.ug.RemoteModel.getIsovolumeAt()
getIsovolumeAt(index: number): Isovolume

Returns the Isovolume at the given index.

The index must be between 0 and isovolumeCount - 1.

Parameters

index: number

Returns: Isovolume

cee.ug.RemoteModel.getIsovolumeById()
getIsovolumeById(id: number): Isovolume

Returns the Isovolume with the given id, or null if no match is found.

Parameters

id: number

Returns: Isovolume

cee.ug.RemoteModel.getNodeCount()
getNodeCount(frameIndex: number): number

Returns the total number of nodes in the given frame

index must be <0..frameCount-1>

Parameters

frameIndex: number

Returns: number

Returns undefined if data for the frame has not yet been received.
cee.ug.RemoteModel.getParticleTraceGroupArray()
getParticleTraceGroupArray(): readonly  ParticleTraceGroup[]

Returns all ParticleTraceGroups in the model.

Returns: readonly  ParticleTraceGroup[]

cee.ug.RemoteModel.getParticleTraceGroupAt()
getParticleTraceGroupAt(index: number): ParticleTraceGroup

Returns the ParticleTraceGroup at the given index.

The index must be between 0 and particleTraceGroupCount - 1.

Parameters

index: number

Returns: ParticleTraceGroup

cee.ug.RemoteModel.getParticleTraceGroupById()
getParticleTraceGroupById(id: number): ParticleTraceGroup

Returns the ParticleTraceGroup with the given id, or null if no match was found.

Parameters

id: number

Returns: ParticleTraceGroup

cee.ug.RemoteModel.getPartSettingsArray()
getPartSettingsArray(): readonly  PartSettings[]

Returns PartSettings for all parts in the model.

Returns: readonly  PartSettings[]

cee.ug.RemoteModel.getPartSettingsAt()
getPartSettingsAt(partIndex: number): PartSettings

Returns part settings for the part at the given index.

The index must be between 0 and partCount - 1.

Parameters

partIndex: number

Returns: PartSettings

cee.ug.RemoteModel.getPartSettingsById()
getPartSettingsById(geometryIndex: number, partId: number): PartSettings

Returns the part settings for the part with the given geometry index and part id.

Parameters

geometryIndex: number

The index of the geometry the part belongs to. In most cases there is only one geometry and this parameter should be 0.

partId: number

The id of the part to find.

Returns: PartSettings

cee.ug.RemoteModel.getScalarResultMaximumValue()
getScalarResultMaximumValue(resultId: number): number

Returns the maximum value for all items currently loaded in the RemoteModel for the given scalar result.

The resultId must refer to one of the scalar results in ModelDirectory.scalarResultArray.

Note: This method only works for results that are currently in use in the client. If you need the maximum value of any scalar result, you can use the QueryResultMinMax class.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getScalarResultMinimumValue()
getScalarResultMinimumValue(resultId: number): number

Returns the minimum value for all items currently loaded in the RemoteModel for the given scalar result.

The resultId must refer to one of the scalar results in ModelDirectory.scalarResultArray.

Note: This method only works for results that are currently in use in the client. If you need the minimum value of any scalar result, you can use the QueryResultMinMax class.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getScalarSettingsArray()
getScalarSettingsArray(): readonly  ScalarSettings[]

Returns ScalarSettings for all scalar results in the model.

Returns: readonly  ScalarSettings[]

cee.ug.RemoteModel.getScalarSettingsAt()
getScalarSettingsAt(resultIndex: number): ScalarSettings

Returns the ScalarSettings for the result at the given index.

The index must be between 0 and scalarSettingsCount - 1.

Use the returned object to modify the settings of the scalar result

Parameters

resultIndex: number

Returns: ScalarSettings

cee.ug.RemoteModel.getScalarSettingsById()
getScalarSettingsById(resultId: number): ScalarSettings

Returns the ScalarSettings for the result with the given result id, or null if no match is found.

The resultId must refer to one of the scalar results in ModelDirectory.scalarResultArray.

Use the returned object to modify the settings of the scalar result

Parameters

resultId: number

Returns: ScalarSettings

cee.ug.RemoteModel.getVectorResultMaximumLength()
getVectorResultMaximumLength(resultId: number): number

Returns the maximum length for all items currently loaded in the RemoteModel for the given vector result.

The resultId must refer to one of the vector results in ModelDirectory.vectorResultArray.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getVectorResultMinimumLength()
getVectorResultMinimumLength(resultId: number): number

Returns the minimum length for all items currently loaded in the RemoteModel for the given vector result.

The resultId must refer to one of the vector results in ModelDirectory.vectorResultArray.

Parameters

resultId: number

Returns: number

Returns undefined if the result has not been loaded or if the resultId is invalid.
cee.ug.RemoteModel.getVectorSettingsArray()
getVectorSettingsArray(): readonly  VectorSettings[]

Returns VectorSettings for all vector results in the model.

Returns: readonly  VectorSettings[]

cee.ug.RemoteModel.getVectorSettingsAt()
getVectorSettingsAt(resultIndex: number): VectorSettings

Returns the VectorSettings for the result at the given index.

The index must be between 0 and vectorSettingsCount - 1.

Use the returned object to modify the settings of the vector result

Parameters

resultIndex: number

Returns: VectorSettings

cee.ug.RemoteModel.getVectorSettingsById()
getVectorSettingsById(resultId: number): VectorSettings

Returns the VectorSettings for the result with the given result id, or null if no match is found.

The resultId must refer to one of the vector results in ModelDirectory.vectorResultArray.

Use the returned object to modify the settings of the vector result

Parameters

resultId: number

Returns: VectorSettings

cee.ug.RemoteModel.isDataSourceRequestInProgress()
isDataSourceRequestInProgress(): boolean

Returns true if an executeDataSourceRequest call is in progress.

Use this to check before calling executeDataSourceRequest, as this will throw if a request is in flight

Returns: boolean

cee.ug.RemoteModel.isOpen()
isOpen(): boolean

Returs true when the model is successfully opened, i.e. once the callback passed to openModel is called.

Returns: boolean

cee.ug.RemoteModel.isPointCoveredBySurface()
isPointCoveredBySurface(point: Vec3, view: View): boolean

Determines whether the given point is currently covered by a surface in the given view.

Parameters

point: Vec3

view: View

Returns: boolean

cee.ug.RemoteModel.isPollForDataSourceChangesInProgress()
isPollForDataSourceChangesInProgress(): boolean

Returns true if a pollForDataSourceChanges call is in progress.

Use this to check before calling pollForDataSourceChanges, as this will throw if a request is in flight

Returns: boolean

cee.ug.RemoteModel.isPreloadingEnabled()
isPreloadingEnabled(): boolean

Returns true if pre-loading is enabled.

Returns: boolean

cee.ug.RemoteModel.openModel()
openModel(modelKey: string, openCompletedCallback: OpenModelCallback, options: OpenModelOptions): void

Opens the model with the given modelKey in this RemoteModel.

Opens a model on the server and prepares to stream it to the client. If the model is opened successfully (as indicated when the optional callback is invoked) the initial step of the CAE model will be streamed to the client.

Parameters

modelKey: string

The identifier of the model to open. This will be translated on the server into a filename before the model is opened. This translation is done by the modelFileFromKey() function that is provided to createServerInstance() on the visualization server.

openCompletedCallback: OpenModelCallback

Callback function that will be called when the model is ready to be used in the client. This will also be called if any errors occur (file not found etc.). When this is called the ModelDirectory will have been populated with the contents of the server CAE analysis.

options: OpenModelOptions

Open model options. Provide any default calculators and/or an internal configString. See OpenModelOptions for more info.

Example: Customize the initial appearance of the model in the callback:

   // Remove any old models
   var view = myViewer.getViewAt(0);
   view.removeAllModels();

   // Open a new RemoteModel from the CAE server
   var mySocket = io('http://localhost:8998');
   myModel = new cee.ug.RemoteModel(mySocket, "");
   view.addModel(myModel);

   // Open the file on the server, setup the viz when it is done
   myModel.openModel("", function(err, model) {
       // Note: The model is now ready to use and the ModelDirectory is populated
       // with the model context received from the server

       // Show the first scalar as filled contours (if any)
       if (model.modelDirectory.scalarResultArray.length > 0) {
           model.modelSpec.fringesResultId = model.modelDirectory.scalarResultArray[0].id;
       }

       // Modify the part settings: First part transparent, the rest with surf mesh
       for (var ps of model.getPartSettingsArray()) {
           ps.drawStyle = cee.ug.DrawStyle.SURFACE_OUTLINE_MESH;
           ps.opacity = 0.5;
       }
   });

This code sample produces the following image in the 3D Viewer:

.. image:: /images/RemoteModel_open.png
   :alt: None

Returns: void

cee.ug.RemoteModel.pollForDataSourceChanges()
pollForDataSourceChanges(pollForDataSourceChangesCompletedCallback: PollForDataSourceChangesCallback): void

Poll the current data source for changes.

Note: Only one poll can be in flight at any given time, so calling this method while a poll is being processed will throw. To make sure you do not do that, use the isPollForDataSourceChangesInProgress method to check for any ongoing polls.

Parameters

pollForDataSourceChangesCompletedCallback: PollForDataSourceChangesCallback

Returns: void

cee.ug.RemoteModel.rayIntersect()
rayIntersect(frameIndex: number, ray: Ray, rayIntersectCallback: RayIntersectCallback): void

Performs picking on the remote server model.

This will perform a picking action on the remote server with the given ray. The provided callback will be called when the result is available. The hitItem provided to this callback will contain detailed information about the element that was hit in the CAE model.

To do the picking at the current state/time step, use the model.currentFrameIndex property.

Parameters

frameIndex: number

ray: Ray

rayIntersectCallback: RayIntersectCallback

Returns: void

cee.ug.RemoteModel.recreateResultCalculator()
recreateResultCalculator(config: CreateResultCalculatorConfig, callback: CreateResultCalculatorCallback): void

Recreate the result with the given calculatorId and resultIdString.

Use this method to update an already existing calculator result. From the client side it will seem like the result is just updated with the new initString, but on the server the actual calculator instance will be deleted and a new one will be initialized with the given initString.

The result will keep its id (number) so no updates are needed to the model spec or feature extraction items.

Parameters

config: CreateResultCalculatorConfig

callback: CreateResultCalculatorCallback

An optional callback function triggered when the new result is available

Returns: void

Examples

// Basic usage
model.recreateResultCalculator({
    calculatorId: "MyCalculator",
    resultIdString: "MyResult",
    initString: "MyCustomExpression"
});

// With coordinate system
model.recreateResultCalculator({
    calculatorId: "MyCalculator",
    resultIdString: "MyResult",
    initString: "MyCustomExpression",
    coordSystemString: "type=cylindrical;origin=10.0,5.0,0.0;orientation=1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0"
});
cee.ug.RemoteModel.reloadModel()
reloadModel(reloadCompletedCallback: ReloadModelCallback): void

Reload model, pick up any changes on the server since the open of the analysis.

Parameters

reloadCompletedCallback: ReloadModelCallback

Returns: void

cee.ug.RemoteModel.sendToCloud()
sendToCloud(view: View, config: SendToCloudConfig, callback: SendToCloudCallback): void

Share the model on the web using the Envision One-Click-Sharing service.

With this method you can share the remote model (with the current settings) to the Ceetron Cloud cloud service.

You can either use the default https://cloud.ceetron.com service, or use your own hosted sharing portal. The Ceetron Cloud Portal can be customized and installed on most cloud and on-premises servers.

Parameters

view: View

config: SendToCloudConfig

callback: SendToCloudCallback

Returns: void

cee.ug.RemoteModel.setColorLegendTitle()
setColorLegendTitle(resultId: number, title: string): void

Set the title of the color legend with the given result Id

This will update any current legends, and also be used as the title whenever the legend is later created.

Parameters

resultId: number

title: string

Returns: void

cee.ug.RemoteModel.setCommunicationPerformanceHandler()
setCommunicationPerformanceHandler(performanceHandler: CommunicationPerformanceHandler): void

Sets a handler function that will be called with information about the current communication.

See CommunicationPerformanceData for more information.

Parameters

Returns: void

cee.ug.RemoteModel.setDrawStyleAllParts()
setDrawStyleAllParts(drawStyle: DrawStyle, opacity: number): void

Sets the draw style for all parts in the model

This is just a helper for setting PartSettings.drawStyle for all parts in the model, and optionally set opacity if provided.

Parameters

drawStyle: DrawStyle

opacity: number

Returns: void

cee.ug.RemoteModel.setOneShotDataStreamingCompleteCallback()
setOneShotDataStreamingCompleteCallback(dataStreamingCompleteCallback: DataStreamingCompleteCallback): void

Sets a one- shot callback that will be called the next time we observe that data streaming is complete

Parameters

dataStreamingCompleteCallback: DataStreamingCompleteCallback

Returns: void

cee.ug.RemoteModel.setProgressHandler()
setProgressHandler(progressHandler: ProgressHandler): void

Sets a handler function that will be called whenever a progress indication packet is received from the visualization server.

Parameters

progressHandler: ProgressHandler

Returns: void

cee.ug.RemoteModel.setReaderOptions()
setReaderOptions(readerIdString: string, options: Unhandled type Opaque): void

Set options for the reader with the given readerIdString

The options will be sent to the server and used whenever a file of the given type is opened.

Available options:

  • VTK (vtu/pvtu/pvd):
  • readerIdString: “VTK”
  • options:
  • ALL_VECTORS_AS_DISPLACEMENT (bool) : If set to true, all vector results in the file will be reported as displacements.
  • WELD_NODES_FOR_JOINT_PARTS (bool) : If set to true, all nodes in joint parts are welded together
  • WELD_NODES_PART_FIELD_NAME (string) : Set the name of the field used to identify parts in the model, for instance “PartID”. The chosen field must contain integers. The default value is “”. This option only applies when WELD_NODES_FOR_JOINT_PARTS is set to true.
  • HOOPS Access:
  • readerIdString: “CEETRON_ACCESS” (most CAE formats)
  • options:
  • USE_UNDEFINED_RESULTS (bool) : If true, undefined results will be reported as undefined. If false, undefined results will be reported as zero.

OpenFoamProvider: See the readme file for the provider.

Example:

this.m_model.setReaderOptions("OpenFoamProvider", {
  "LOAD_BC_PARTS": true,
  "NODE_AVG_RES": true,
  "HIDE_PARALLEL_INTERFACES": false,
  "UPDATE_GEOMETRY_FOR_AMI": false
});

this.m_model.setReaderOptions("VTK", {
    "ALL_VECTORS_AS_DISPLACEMENT": true,
});

Parameters

readerIdString: string

options: Unhandled type Opaque

Returns: void

cee.ug.RemoteModel.setResultCalculatorParams()
setResultCalculatorParams(calculatorId: string, resultIdString: string, paramsDict: Unhandled type Opaque): void

Sets result calculator parameters for the given result calculator result.

The result will automatically be updated.

Example:

model.setResultCalculatorParams(calcId, resIdString,  { "scaleFactor" : 2.0 });

Parameters

calculatorId: string

resultIdString: string

paramsDict: Unhandled type Opaque

Returns: void

cee.ug.RemoteModel.setResultRangeChangedHandler()
setResultRangeChangedHandler(resultRangeChangedHandler: ResultRangeChangedHandler): void

Specifies the handler function that will be called whenever any result changes in the model. This will be called when a result is loaded the first time or when changing time step.

This might be useful for updating the UI, e.g. the minimum and maximum values on a slider for an isosurface.

Parameters

resultRangeChangedHandler: ResultRangeChangedHandler

Returns: void

cee.ug.RemoteModel.setServerErrorHandler()
setServerErrorHandler(errorHandler: ServerErrorHandler): void

Sets a handler function that will be called whenever an error packet is received from the visualization server.

Parameters

errorHandler: ServerErrorHandler

Returns: void

cee.ug.RemoteModel.setServerLogContextKeyValueArr()
setServerLogContextKeyValueArr(keyValueArr: { key: string, value: string }[]): void

Set an array of key,value pairs that will be included as a context in the server log.

This key,value pairs will be available in the JSON type log, and will be included until a new key,value array is specified. To clear any current settings, pass in an empty array.

This could be used to enhance the telemetry support in your cloud solution.

Parameters

keyValueArr: { key: string, value: string }[]

Returns: void

cee.ug.RemoteModel.startPostponedStreaming()
startPostponedStreaming(): void

Start the streaming of the initial 3d model from the server.

Note: Calling this method is only needed when using the openCompletedCallback parameter to OpenModel and returning POSTPONE_STREAMING.

Returns: void

static cee.ug.RemoteModel.getCustomServerInfo()

static

getCustomServerInfo(socketIOClient_socketInstance: any, callback: (customData: any) => void): void

Static method to get custom server info from the UgServer.

This info is specified on the server in the createServerInstance() method or the constructor to ServerInstance.

Default response is null.

Parameters

socketIOClient_socketInstance: any

callback: (customData: any) => void

Returns: void