.. role:: ts-api-decorator

###########
RemoteModel
###########

.. js:module:: cee.ug
   :noindex:

.. container:: ts-api-section

   .. js:class:: 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:


      .. code-block:: javascript

         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 
 

      .. code-block:: javascript

         // 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:

      .. image:: /images/RemoteModel.png





.. container:: api-index-section

   .. rubric:: Constructors

   .. rst-class:: api-index-list-item api-kind-constructor api-parent-kind-class

   * :js:meth:`~cee.ug.RemoteModel.constructor`



.. container:: api-index-section

   .. rubric:: Accessors

   .. rst-class:: api-index-list-item api-kind-accessor api-parent-kind-class

   * :js:attr:`~cee.ug.RemoteModel.animation`
   * :js:attr:`~cee.ug.RemoteModel.currentFrameIndex`
   * :js:attr:`~cee.ug.RemoteModel.currentStepText`
   * :js:attr:`~cee.ug.RemoteModel.cuttingPlaneCount`
   * :js:attr:`~cee.ug.RemoteModel.displacementSettingsCount`
   * :js:attr:`~cee.ug.RemoteModel.frameCount`
   * :js:attr:`~cee.ug.RemoteModel.isosurfaceCount`
   * :js:attr:`~cee.ug.RemoteModel.isovolumeCount`
   * :js:attr:`~cee.ug.RemoteModel.mirrorSettings`
   * :js:attr:`~cee.ug.RemoteModel.modelDirectory`
   * :js:attr:`~cee.ug.RemoteModel.modelSettings`
   * :js:attr:`~cee.ug.RemoteModel.modelSpec`
   * :js:attr:`~cee.ug.RemoteModel.name`
   * :js:attr:`~cee.ug.RemoteModel.partCount`
   * :js:attr:`~cee.ug.RemoteModel.particleTraceGroupCount`
   * :js:attr:`~cee.ug.RemoteModel.scalarSettingsCount`
   * :js:attr:`~cee.ug.RemoteModel.vectorSettingsCount`



.. container:: api-index-section

   .. rubric:: Methods

   .. rst-class:: api-index-list-item api-kind-method api-parent-kind-class

   * :js:meth:`~cee.ug.RemoteModel.addCuttingPlane`
   * :js:meth:`~cee.ug.RemoteModel.addIsosurface`
   * :js:meth:`~cee.ug.RemoteModel.addIsovolume`
   * :js:meth:`~cee.ug.RemoteModel.addNextServerUpdateCompletedCallback`
   * :js:meth:`~cee.ug.RemoteModel.addParticleTraceGroup`
   * :js:meth:`~cee.ug.RemoteModel.applyVTFxCase`
   * :js:meth:`~cee.ug.RemoteModel.clientSideRayIntersect`
   * :js:meth:`~cee.ug.RemoteModel.closeModel`
   * :js:meth:`~cee.ug.RemoteModel.createResultCalculator`
   * :js:meth:`~cee.ug.RemoteModel.createTrianglePicker`
   * :js:meth:`~cee.ug.RemoteModel.createVisibleObjectPicker`
   * :js:meth:`~cee.ug.RemoteModel.deleteAllCuttingPlanes`
   * :js:meth:`~cee.ug.RemoteModel.deleteAllIsosurfaces`
   * :js:meth:`~cee.ug.RemoteModel.deleteAllIsovolumes`
   * :js:meth:`~cee.ug.RemoteModel.deleteAllParticleTraceGroups`
   * :js:meth:`~cee.ug.RemoteModel.deleteCuttingPlaneById`
   * :js:meth:`~cee.ug.RemoteModel.deleteIsosurfaceById`
   * :js:meth:`~cee.ug.RemoteModel.deleteIsovolumeById`
   * :js:meth:`~cee.ug.RemoteModel.deleteParticleTraceGroupById`
   * :js:meth:`~cee.ug.RemoteModel.deleteResultCalculator`
   * :js:meth:`~cee.ug.RemoteModel.enablePreloading`
   * :js:meth:`~cee.ug.RemoteModel.executeDataSourceRequest`
   * :js:meth:`~cee.ug.RemoteModel.getBoundingBox`
   * :js:meth:`~cee.ug.RemoteModel.getClientSidePartBoundingBox`
   * :js:meth:`~cee.ug.RemoteModel.getCuttingPlaneArray`
   * :js:meth:`~cee.ug.RemoteModel.getCuttingPlaneAt`
   * :js:meth:`~cee.ug.RemoteModel.getCuttingPlaneById`
   * :js:meth:`~cee.ug.RemoteModel.getDefaultCameraConfig`
   * :js:meth:`~cee.ug.RemoteModel.getDisplacementResultMaximumLength`
   * :js:meth:`~cee.ug.RemoteModel.getDisplacementResultMinimumLength`
   * :js:meth:`~cee.ug.RemoteModel.getDisplacementSettingsArray`
   * :js:meth:`~cee.ug.RemoteModel.getDisplacementSettingsAt`
   * :js:meth:`~cee.ug.RemoteModel.getDisplacementSettingsById`
   * :js:meth:`~cee.ug.RemoteModel.getElementCount`
   * :js:meth:`~cee.ug.RemoteModel.getIsosurfaceArray`
   * :js:meth:`~cee.ug.RemoteModel.getIsosurfaceAt`
   * :js:meth:`~cee.ug.RemoteModel.getIsosurfaceById`
   * :js:meth:`~cee.ug.RemoteModel.getIsovolumeArray`
   * :js:meth:`~cee.ug.RemoteModel.getIsovolumeAt`
   * :js:meth:`~cee.ug.RemoteModel.getIsovolumeById`
   * :js:meth:`~cee.ug.RemoteModel.getNodeCount`
   * :js:meth:`~cee.ug.RemoteModel.getParticleTraceGroupArray`
   * :js:meth:`~cee.ug.RemoteModel.getParticleTraceGroupAt`
   * :js:meth:`~cee.ug.RemoteModel.getParticleTraceGroupById`
   * :js:meth:`~cee.ug.RemoteModel.getPartSettingsArray`
   * :js:meth:`~cee.ug.RemoteModel.getPartSettingsAt`
   * :js:meth:`~cee.ug.RemoteModel.getPartSettingsById`
   * :js:meth:`~cee.ug.RemoteModel.getScalarResultMaximumValue`
   * :js:meth:`~cee.ug.RemoteModel.getScalarResultMinimumValue`
   * :js:meth:`~cee.ug.RemoteModel.getScalarSettingsArray`
   * :js:meth:`~cee.ug.RemoteModel.getScalarSettingsAt`
   * :js:meth:`~cee.ug.RemoteModel.getScalarSettingsById`
   * :js:meth:`~cee.ug.RemoteModel.getVectorResultMaximumLength`
   * :js:meth:`~cee.ug.RemoteModel.getVectorResultMinimumLength`
   * :js:meth:`~cee.ug.RemoteModel.getVectorSettingsArray`
   * :js:meth:`~cee.ug.RemoteModel.getVectorSettingsAt`
   * :js:meth:`~cee.ug.RemoteModel.getVectorSettingsById`
   * :js:meth:`~cee.ug.RemoteModel.isDataSourceRequestInProgress`
   * :js:meth:`~cee.ug.RemoteModel.isOpen`
   * :js:meth:`~cee.ug.RemoteModel.isPointCoveredBySurface`
   * :js:meth:`~cee.ug.RemoteModel.isPollForDataSourceChangesInProgress`
   * :js:meth:`~cee.ug.RemoteModel.isPreloadingEnabled`
   * :js:meth:`~cee.ug.RemoteModel.openModel`
   * :js:meth:`~cee.ug.RemoteModel.pollForDataSourceChanges`
   * :js:meth:`~cee.ug.RemoteModel.rayIntersect`
   * :js:meth:`~cee.ug.RemoteModel.recreateResultCalculator`
   * :js:meth:`~cee.ug.RemoteModel.reloadModel`
   * :js:meth:`~cee.ug.RemoteModel.sendToCloud`
   * :js:meth:`~cee.ug.RemoteModel.setColorLegendTitle`
   * :js:meth:`~cee.ug.RemoteModel.setCommunicationPerformanceHandler`
   * :js:meth:`~cee.ug.RemoteModel.setDrawStyleAllParts`
   * :js:meth:`~cee.ug.RemoteModel.setOneShotDataStreamingCompleteCallback`
   * :js:meth:`~cee.ug.RemoteModel.setProgressHandler`
   * :js:meth:`~cee.ug.RemoteModel.setReaderOptions`
   * :js:meth:`~cee.ug.RemoteModel.setResultCalculatorParams`
   * :js:meth:`~cee.ug.RemoteModel.setResultRangeChangedHandler`
   * :js:meth:`~cee.ug.RemoteModel.setServerErrorHandler`
   * :js:meth:`~cee.ug.RemoteModel.setServerLogContextKeyValueArr`
   * :js:meth:`~cee.ug.RemoteModel.startPostponedStreaming`
   * :js:meth:`~cee.ug.RemoteModel.getCustomServerInfo`





------------

Constructors
============

.. container:: ts-api-section

   .. js:function:: RemoteModel.constructor( socketIOClient_socketInstance)

      :param socketIOClient_socketInstance: None
      :type socketIOClient_socketInstance: any


      Creates a RemoteModel.

      A socket connection to a live UgServer must be provided.

      Example:

      .. code-block:: javascript

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



      :rtype: RemoteModel



Accessors
=========

.. container:: ts-api-section

   .. js:function:: RemoteModel.animation()



      The animation control for this RemoteModel.


      :rtype: Animation



.. container:: ts-api-section

   .. js:function:: RemoteModel.currentFrameIndex()



      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.


      :rtype: number

   .. js:function:: RemoteModel.currentFrameIndex( frameIndex)

      :param frameIndex: None
      :type frameIndex: number


      :rtype: void



.. container:: ts-api-section

   .. js:function:: RemoteModel.currentStepText()



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


      :rtype: string



.. container:: ts-api-section

   .. js:function:: RemoteModel.cuttingPlaneCount()



      The number of cutting planes in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.displacementSettingsCount()



      The number of displacement settings in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.frameCount()



      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.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.isosurfaceCount()



      The number of isosurfaces in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.isovolumeCount()



      The number of isovolumes in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.mirrorSettings()



      The mirror/symmetry settings for this RemoteModel

      See ``MirrorSettings`` for more info.


      :rtype: MirrorSettings



.. container:: ts-api-section

   .. js:function:: RemoteModel.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.


      :rtype: ModelDirectory



.. container:: ts-api-section

   .. js:function:: RemoteModel.modelSettings()



      The model settings for this RemoteModel

      See ``ModelSettings`` for more info.


      :rtype: ModelSettings



.. container:: ts-api-section

   .. js:function:: RemoteModel.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.


      :rtype: ModelSpec



.. container:: ts-api-section

   .. js:function:: RemoteModel.name()



      Name of the geometry model. 

      Mainly used for debugging.


      :rtype: string

   .. js:function:: RemoteModel.name( name)

      :param name: None
      :type name: string


      :rtype: void



.. container:: ts-api-section

   .. js:function:: RemoteModel.partCount()



      The number of parts in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.particleTraceGroupCount()



      The number of particle trace groups in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.scalarSettingsCount()



      The number of scalar settings in the model.


      :rtype: number



.. container:: ts-api-section

   .. js:function:: RemoteModel.vectorSettingsCount()



      The number of vector settings in the model.


      :rtype: number



Methods
=======

.. rst-class:: ts-api-section

addCuttingPlane
---------------

.. js:method:: RemoteModel.addCuttingPlane()



   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: Returns the new ``CuttingPlane``.


   :rtype: CuttingPlane

.. rst-class:: ts-api-section

addIsosurface
-------------

.. js:method:: RemoteModel.addIsosurface()



   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:

   * ``Isosurface.isoScalarResultId``: the fringes result or the first available scalar
   * ``Isosurface.mapScalarResultId``: same as above
   * ``Isosurface.isoValue``: the middle of the range if known, else 0.5

   :returns: Returns the new ``Isosurface``.


   :rtype: Isosurface

.. rst-class:: ts-api-section

addIsovolume
------------

.. js:method:: RemoteModel.addIsovolume()



   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:

   * ``Isovolume.isoScalarResultId``: the fringes result or the first available scalar
   * ``Isovolume.mapScalarResultId``: same as above
   * ``Isovolume.minimumIsoValue``: the minimum of the range if known, else 0
   * ``Isovolume.maximumIsoValue``: the middle of the range if known, else 0.5

   :returns: Returns the new ``Isovolume``.


   :rtype: Isovolume

.. rst-class:: ts-api-section

addNextServerUpdateCompletedCallback
------------------------------------

.. js:method:: RemoteModel.addNextServerUpdateCompletedCallback( serverVisuaizationUpdateCompleteCallback)

   :param serverVisuaizationUpdateCompleteCallback: None
   :type serverVisuaizationUpdateCompleteCallback: ServerUpdateCompletedCallback


   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.


   :rtype: void

.. rst-class:: ts-api-section

addParticleTraceGroup
---------------------

.. js:method:: RemoteModel.addParticleTraceGroup()



   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: Returns the new ``ParticleTraceGroup``.


   :rtype: ParticleTraceGroup

.. rst-class:: ts-api-section

applyVTFxCase
-------------

.. js:method:: RemoteModel.applyVTFxCase( caseId[, applyVTFxCaseCompletedCallback])

   :param caseId: None
   :type caseId: number
   :param applyVTFxCaseCompletedCallback: :ts-api-decorator:`optional` None
   :type applyVTFxCaseCompletedCallback: ApplyVTFxCaseCallback


   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


   :rtype: void

.. rst-class:: ts-api-section

clientSideRayIntersect
----------------------

.. js:method:: RemoteModel.clientSideRayIntersect( ray)

   :param ray: None
   :type ray: Ray


   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


   :rtype: ClientSideHitItem

.. rst-class:: ts-api-section

closeModel
----------

.. js:method:: RemoteModel.closeModel()



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


   :rtype: void

.. rst-class:: ts-api-section

createResultCalculator
----------------------

.. js:method:: RemoteModel.createResultCalculator( config[, callback])

   :param config: See ``CreateResultCalculatorConfig``
   :type config: CreateResultCalculatorConfig
   :param callback: :ts-api-decorator:`optional` 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.
   :type callback: CreateResultCalculatorCallback


   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).

   :example:  .. code-block:: javascript     // 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"    }); 


   :rtype: void

.. rst-class:: ts-api-section

createTrianglePicker
--------------------

.. js:method:: RemoteModel.createTrianglePicker( view)

   :param view: None
   :type view: View


   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.


   :rtype: TrianglePicker

.. rst-class:: ts-api-section

createVisibleObjectPicker
-------------------------

.. js:method:: RemoteModel.createVisibleObjectPicker( view)

   :param view: None
   :type view: View


   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.


   :rtype: VisibleObjectPicker

.. rst-class:: ts-api-section

deleteAllCuttingPlanes
----------------------

.. js:method:: RemoteModel.deleteAllCuttingPlanes()



   Deletes all ``CuttingPlanes`` from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteAllIsosurfaces
--------------------

.. js:method:: RemoteModel.deleteAllIsosurfaces()



   Deletes all ``Isosurfaces`` from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteAllIsovolumes
-------------------

.. js:method:: RemoteModel.deleteAllIsovolumes()



   Delete all ``Isovolumes`` from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteAllParticleTraceGroups
----------------------------

.. js:method:: RemoteModel.deleteAllParticleTraceGroups()



   Deletes all ``ParticleTraceGroup`` from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteCuttingPlaneById
----------------------

.. js:method:: RemoteModel.deleteCuttingPlaneById( id)

   :param id: None
   :type id: number


   Deletes the ``CuttingPlane`` with the given id from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteIsosurfaceById
--------------------

.. js:method:: RemoteModel.deleteIsosurfaceById( id)

   :param id: None
   :type id: number


   Deletes the ``Isosurface`` with the given id from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteIsovolumeById
-------------------

.. js:method:: RemoteModel.deleteIsovolumeById( id)

   :param id: None
   :type id: number


   Deletes the ``Isovolume`` with the given id from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteParticleTraceGroupById
----------------------------

.. js:method:: RemoteModel.deleteParticleTraceGroupById( id)

   :param id: None
   :type id: number


   Deletes the ``ParticleTraceGroup`` with the given id from the model.


   :rtype: void

.. rst-class:: ts-api-section

deleteResultCalculator
----------------------

.. js:method:: RemoteModel.deleteResultCalculator( calculatorId, resultIdString)

   :param calculatorId: None
   :type calculatorId: string
   :param resultIdString: None
   :type resultIdString: string


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


   :rtype: void

.. rst-class:: ts-api-section

enablePreloading
----------------

.. js:method:: RemoteModel.enablePreloading( enable)

   :param enable: None
   :type enable: boolean


   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).


   :rtype: void

.. rst-class:: ts-api-section

executeDataSourceRequest
------------------------

.. js:method:: RemoteModel.executeDataSourceRequest( message, data[, callback])

   :param message: None
   :type message: string
   :param data: None
   :type data: string
   :param callback: :ts-api-decorator:`optional` None
   :type callback: DataSourceRequestCallback


   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.


   :rtype: void

.. rst-class:: ts-api-section

getBoundingBox
--------------

.. js:method:: RemoteModel.getBoundingBox([ _options])

   :param _options: :ts-api-decorator:`optional` None
   :type _options: ModelBoundingBoxOptions


   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.


   :rtype: BoundingBox

.. rst-class:: ts-api-section

getClientSidePartBoundingBox
----------------------------

.. js:method:: RemoteModel.getClientSidePartBoundingBox( geometryIndex, partId)

   :param geometryIndex: None
   :type geometryIndex: number
   :param partId: None
   :type partId: number


   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.


   :rtype: BoundingBox

.. rst-class:: ts-api-section

getCuttingPlaneArray
--------------------

.. js:method:: RemoteModel.getCuttingPlaneArray()



   Returns all ``CuttingPlane``s in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getCuttingPlaneAt
-----------------

.. js:method:: RemoteModel.getCuttingPlaneAt( index)

   :param index: None
   :type index: number


   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.


   :rtype: CuttingPlane

.. rst-class:: ts-api-section

getCuttingPlaneById
-------------------

.. js:method:: RemoteModel.getCuttingPlaneById( id)

   :param id: None
   :type id: number


   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.


   :rtype: CuttingPlane

.. rst-class:: ts-api-section

getDefaultCameraConfig
----------------------

.. js:method:: RemoteModel.getDefaultCameraConfig()



   Returns default camera configuration for this model if it exists


   :rtype: CameraConfig

.. rst-class:: ts-api-section

getDisplacementResultMaximumLength
----------------------------------

.. js:method:: RemoteModel.getDisplacementResultMaximumLength( resultId)

   :param resultId: None
   :type resultId: 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``.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getDisplacementResultMinimumLength
----------------------------------

.. js:method:: RemoteModel.getDisplacementResultMinimumLength( resultId)

   :param resultId: None
   :type resultId: 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``.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getDisplacementSettingsArray
----------------------------

.. js:method:: RemoteModel.getDisplacementSettingsArray()



   Returns ``DisplacementSettings`` for all displacement results in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getDisplacementSettingsAt
-------------------------

.. js:method:: RemoteModel.getDisplacementSettingsAt( resultIndex)

   :param resultIndex: None
   :type resultIndex: number


   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.


   :rtype: DisplacementSettings

.. rst-class:: ts-api-section

getDisplacementSettingsById
---------------------------

.. js:method:: RemoteModel.getDisplacementSettingsById( resultId)

   :param resultId: None
   :type resultId: number


   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.


   :rtype: DisplacementSettings

.. rst-class:: ts-api-section

getElementCount
---------------

.. js:method:: RemoteModel.getElementCount( frameIndex)

   :param frameIndex: None
   :type frameIndex: number


   Returns the total number of elements in the given frame

   frameIndex must be <0..frameCount-1>

   :returns: Returns undefined if data for the frame has not yet been received.


   :rtype: number

.. rst-class:: ts-api-section

getIsosurfaceArray
------------------

.. js:method:: RemoteModel.getIsosurfaceArray()



   Returns all ``Isosurfaces`` in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getIsosurfaceAt
---------------

.. js:method:: RemoteModel.getIsosurfaceAt( index)

   :param index: None
   :type index: number


   Returns the ``Isosurface`` at the given index.

   The index must be between 0 and isosurfaceCount - 1.


   :rtype: Isosurface

.. rst-class:: ts-api-section

getIsosurfaceById
-----------------

.. js:method:: RemoteModel.getIsosurfaceById( id)

   :param id: None
   :type id: number


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


   :rtype: Isosurface

.. rst-class:: ts-api-section

getIsovolumeArray
-----------------

.. js:method:: RemoteModel.getIsovolumeArray()



   Returns all the ``Isovolumes`` in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getIsovolumeAt
--------------

.. js:method:: RemoteModel.getIsovolumeAt( index)

   :param index: None
   :type index: number


   Returns the ``Isovolume`` at the given index.

   The index must be between 0 and isovolumeCount - 1.


   :rtype: Isovolume

.. rst-class:: ts-api-section

getIsovolumeById
----------------

.. js:method:: RemoteModel.getIsovolumeById( id)

   :param id: None
   :type id: number


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


   :rtype: Isovolume

.. rst-class:: ts-api-section

getNodeCount
------------

.. js:method:: RemoteModel.getNodeCount( frameIndex)

   :param frameIndex: None
   :type frameIndex: number


   Returns the total number of nodes in the given frame

   index must be <0..frameCount-1>

   :returns: Returns undefined if data for the frame has not yet been received.


   :rtype: number

.. rst-class:: ts-api-section

getParticleTraceGroupArray
--------------------------

.. js:method:: RemoteModel.getParticleTraceGroupArray()



   Returns all ``ParticleTraceGroups`` in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getParticleTraceGroupAt
-----------------------

.. js:method:: RemoteModel.getParticleTraceGroupAt( index)

   :param index: None
   :type index: number


   Returns the ``ParticleTraceGroup`` at the given index.

   The index must be between 0 and particleTraceGroupCount - 1.


   :rtype: ParticleTraceGroup

.. rst-class:: ts-api-section

getParticleTraceGroupById
-------------------------

.. js:method:: RemoteModel.getParticleTraceGroupById( id)

   :param id: None
   :type id: number


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


   :rtype: ParticleTraceGroup

.. rst-class:: ts-api-section

getPartSettingsArray
--------------------

.. js:method:: RemoteModel.getPartSettingsArray()



   Returns ``PartSettings`` for all parts in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getPartSettingsAt
-----------------

.. js:method:: RemoteModel.getPartSettingsAt( partIndex)

   :param partIndex: None
   :type partIndex: number


   Returns part settings for the part at the given index. 

   The index must be between 0 and partCount - 1.


   :rtype: PartSettings

.. rst-class:: ts-api-section

getPartSettingsById
-------------------

.. js:method:: RemoteModel.getPartSettingsById( geometryIndex, partId)

   :param geometryIndex: The index of the geometry the part belongs to. In most cases there is only one geometry and this parameter should be 0.
   :type geometryIndex: number
   :param partId: The id of the part to find.
   :type partId: number


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


   :rtype: PartSettings

.. rst-class:: ts-api-section

getScalarResultMaximumValue
---------------------------

.. js:method:: RemoteModel.getScalarResultMaximumValue( resultId)

   :param resultId: None
   :type resultId: 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.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getScalarResultMinimumValue
---------------------------

.. js:method:: RemoteModel.getScalarResultMinimumValue( resultId)

   :param resultId: None
   :type resultId: 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.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getScalarSettingsArray
----------------------

.. js:method:: RemoteModel.getScalarSettingsArray()



   Returns ``ScalarSettings`` for all scalar results in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getScalarSettingsAt
-------------------

.. js:method:: RemoteModel.getScalarSettingsAt( resultIndex)

   :param resultIndex: None
   :type resultIndex: number


   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


   :rtype: ScalarSettings

.. rst-class:: ts-api-section

getScalarSettingsById
---------------------

.. js:method:: RemoteModel.getScalarSettingsById( resultId)

   :param resultId: None
   :type resultId: number


   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


   :rtype: ScalarSettings

.. rst-class:: ts-api-section

getVectorResultMaximumLength
----------------------------

.. js:method:: RemoteModel.getVectorResultMaximumLength( resultId)

   :param resultId: None
   :type resultId: 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``.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getVectorResultMinimumLength
----------------------------

.. js:method:: RemoteModel.getVectorResultMinimumLength( resultId)

   :param resultId: None
   :type resultId: 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``.

   :returns: Returns undefined if the result has not been loaded or if the resultId is invalid.


   :rtype: number

.. rst-class:: ts-api-section

getVectorSettingsArray
----------------------

.. js:method:: RemoteModel.getVectorSettingsArray()



   Returns ``VectorSettings`` for all vector results in the model.


   :rtype: unknown

.. rst-class:: ts-api-section

getVectorSettingsAt
-------------------

.. js:method:: RemoteModel.getVectorSettingsAt( resultIndex)

   :param resultIndex: None
   :type resultIndex: number


   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


   :rtype: VectorSettings

.. rst-class:: ts-api-section

getVectorSettingsById
---------------------

.. js:method:: RemoteModel.getVectorSettingsById( resultId)

   :param resultId: None
   :type resultId: number


   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


   :rtype: VectorSettings

.. rst-class:: ts-api-section

isDataSourceRequestInProgress
-----------------------------

.. js:method:: RemoteModel.isDataSourceRequestInProgress()



   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


   :rtype: boolean

.. rst-class:: ts-api-section

isOpen
------

.. js:method:: RemoteModel.isOpen()



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


   :rtype: boolean

.. rst-class:: ts-api-section

isPointCoveredBySurface
-----------------------

.. js:method:: RemoteModel.isPointCoveredBySurface( point, view)

   :param point: None
   :type point: Vec3
   :param view: None
   :type view: View


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


   :rtype: boolean

.. rst-class:: ts-api-section

isPollForDataSourceChangesInProgress
------------------------------------

.. js:method:: RemoteModel.isPollForDataSourceChangesInProgress()



   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


   :rtype: boolean

.. rst-class:: ts-api-section

isPreloadingEnabled
-------------------

.. js:method:: RemoteModel.isPreloadingEnabled()



   Returns true if pre-loading is enabled.


   :rtype: boolean

.. rst-class:: ts-api-section

openModel
---------

.. js:method:: RemoteModel.openModel( modelKey[, openCompletedCallback[, options]])

   :param modelKey: 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.
   :type modelKey: string
   :param openCompletedCallback: :ts-api-decorator:`optional` 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.
   :type openCompletedCallback: OpenModelCallback
   :param options: :ts-api-decorator:`optional` 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:   .. code-block:: javascript  // 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:  ![](/images/RemoteModel_open.png)
   :type options: OpenModelOptions


   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.


   :rtype: void

.. rst-class:: ts-api-section

pollForDataSourceChanges
------------------------

.. js:method:: RemoteModel.pollForDataSourceChanges([ pollForDataSourceChangesCompletedCallback])

   :param pollForDataSourceChangesCompletedCallback: :ts-api-decorator:`optional` None
   :type pollForDataSourceChangesCompletedCallback: PollForDataSourceChangesCallback


   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.


   :rtype: void

.. rst-class:: ts-api-section

rayIntersect
------------

.. js:method:: RemoteModel.rayIntersect( frameIndex, ray, rayIntersectCallback)

   :param frameIndex: None
   :type frameIndex: number
   :param ray: None
   :type ray: Ray
   :param rayIntersectCallback: None
   :type rayIntersectCallback: RayIntersectCallback


   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.


   :rtype: void

.. rst-class:: ts-api-section

recreateResultCalculator
------------------------

.. js:method:: RemoteModel.recreateResultCalculator( config[, callback])

   :param config: See ``CreateResultCalculatorConfig``
   :type config: CreateResultCalculatorConfig
   :param callback: :ts-api-decorator:`optional` An optional callback function triggered when the new result is available
   :type callback: CreateResultCalculatorCallback


   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.

   :example:  .. code-block:: javascript     // 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"    }); 


   :rtype: void

.. rst-class:: ts-api-section

reloadModel
-----------

.. js:method:: RemoteModel.reloadModel([ reloadCompletedCallback])

   :param reloadCompletedCallback: :ts-api-decorator:`optional` None
   :type reloadCompletedCallback: ReloadModelCallback


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


   :rtype: void

.. rst-class:: ts-api-section

sendToCloud
-----------

.. js:method:: RemoteModel.sendToCloud( view, config, callback)

   :param view: None
   :type view: View
   :param config: None
   :type config: SendToCloudConfig
   :param callback: None
   :type callback: SendToCloudCallback


   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.


   :rtype: void

.. rst-class:: ts-api-section

setColorLegendTitle
-------------------

.. js:method:: RemoteModel.setColorLegendTitle( resultId, title)

   :param resultId: None
   :type resultId: number
   :param title: None
   :type title: string


   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.


   :rtype: void

.. rst-class:: ts-api-section

setCommunicationPerformanceHandler
----------------------------------

.. js:method:: RemoteModel.setCommunicationPerformanceHandler( performanceHandler)

   :param performanceHandler: None
   :type performanceHandler: CommunicationPerformanceHandler


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

   See CommunicationPerformanceData for more information.


   :rtype: void

.. rst-class:: ts-api-section

setDrawStyleAllParts
--------------------

.. js:method:: RemoteModel.setDrawStyleAllParts( drawStyle[, opacity])

   :param drawStyle: None
   :type drawStyle: DrawStyle
   :param opacity: :ts-api-decorator:`optional` None
   :type opacity: number


   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.


   :rtype: void

.. rst-class:: ts-api-section

setOneShotDataStreamingCompleteCallback
---------------------------------------

.. js:method:: RemoteModel.setOneShotDataStreamingCompleteCallback( dataStreamingCompleteCallback)

   :param dataStreamingCompleteCallback: None
   :type dataStreamingCompleteCallback: DataStreamingCompleteCallback


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


   :rtype: void

.. rst-class:: ts-api-section

setProgressHandler
------------------

.. js:method:: RemoteModel.setProgressHandler( progressHandler)

   :param progressHandler: None
   :type progressHandler: ProgressHandler


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


   :rtype: void

.. rst-class:: ts-api-section

setReaderOptions
----------------

.. js:method:: RemoteModel.setReaderOptions( readerIdString, options)

   :param readerIdString: None
   :type readerIdString: string
   :param options: None
   :type options: function


   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:

   .. code-block::


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




   .. code-block::


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



   :rtype: void

.. rst-class:: ts-api-section

setResultCalculatorParams
-------------------------

.. js:method:: RemoteModel.setResultCalculatorParams( calculatorId, resultIdString, paramsDict)

   :param calculatorId: None
   :type calculatorId: string
   :param resultIdString: None
   :type resultIdString: string
   :param paramsDict: None
   :type paramsDict: function


   Sets result calculator parameters for the given result calculator result.

   The result will automatically be updated.

   Example:

   .. code-block:: javascript

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



   :rtype: void

.. rst-class:: ts-api-section

setResultRangeChangedHandler
----------------------------

.. js:method:: RemoteModel.setResultRangeChangedHandler( resultRangeChangedHandler)

   :param resultRangeChangedHandler: None
   :type resultRangeChangedHandler: ResultRangeChangedHandler


   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.


   :rtype: void

.. rst-class:: ts-api-section

setServerErrorHandler
---------------------

.. js:method:: RemoteModel.setServerErrorHandler( errorHandler)

   :param errorHandler: None
   :type errorHandler: ServerErrorHandler


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


   :rtype: void

.. rst-class:: ts-api-section

setServerLogContextKeyValueArr
------------------------------

.. js:method:: RemoteModel.setServerLogContextKeyValueArr( keyValueArr)

   :param keyValueArr: None
   :type keyValueArr: [function]


   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.


   :rtype: void

.. rst-class:: ts-api-section

startPostponedStreaming
-----------------------

.. js:method:: RemoteModel.startPostponedStreaming()



   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.


   :rtype: void

.. rst-class:: ts-api-section

:ts-api-decorator:`static` getCustomServerInfo
----------------------------------------------

.. js:method:: RemoteModel.getCustomServerInfo( socketIOClient_socketInstance, callback)

   :param socketIOClient_socketInstance: None
   :type socketIOClient_socketInstance: any
   :param callback: None
   :type callback: function


   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.


   :rtype: void




   .. js:function:: callback( customData)
      :noindex:

      :param customData: None
      :type customData: any


      :rtype: void



