ptolemy.domains.fmi.lib

Class FMU

java.lang.Object

ptolemy.kernel.util.NamedObj

ptolemy.kernel.InstantiableNamedObj

ptolemy.kernel.Entity<T>

ptolemy.kernel.ComponentEntity<T>

ptolemy.actor.AtomicActor<TypedIOPort>

ptolemy.actor.TypedAtomicActor

ptolemy.domains.fmi.lib.FMU

All Implemented Interfaces:

java.lang.Cloneable, Actor, Advanceable, ContinuousStatefulComponent, ContinuousStepSizeController, Executable, FiringsRecordable, Initializable, TypedActor, Changeable, Debuggable, DebugListener, Derivable, Instantiable, ModelErrorHandler, MoMLExportable, Moveable, Nameable

public class FMU
extends TypedAtomicActor
implements Advanceable, ContinuousStepSizeController, ContinuousStatefulComponent

Invoke a Functional Mock-up Interface (FMI) 1.0 Co-Simulation Functional Mock-up Unit (FMU) as a Java Object.

Read in a .fmu file named by the fmuFile parameter. The .fmu file is a zipped file that contains a file named modelDescription.xml that describes the ports and parameters that are created. At run time, method calls are made to C functions that are included in shared libraries included in the .fmu file.

To use this actor from within Vergil, use File -> Import -> Import FMU, which will prompt for a .fmu file. This actor is not available from the actor pane via drag and drop. The problem is that dragging and dropping this actor ends up trying to read fmuImport.fmu, which does not exist. If we added such a file, then dragging and dropping the actor would create an arbitrary actor with arbitrary ports.

FMI documentation may be found at http://www.modelisar.com/fmi.html.

Under the Continuous director, this actor invokes fmiDoStep() at the beginning of the fire() method whenever time has advanced since the last invocation of the fire() method. If at this point the FMU discards the step, then the fire method will nonetheless produce outputs, but they may not be valid for the current time. This should not matter because the Continuous director will call isStepSizeAccurate(), which will return false, and it will revert to the last committed and proceed with a smaller step size. Under the Continuous director, when time is advanced, this actor will be fired several times. The first firing will be at the beginning of the time interval, which matches the last commit time of the last postfire() invocation. The remaining firings will be at times greater than the last commit time. These firings are all speculative, in that any actor may reject the step size when they occur. In the event that a step is rejected, the Continuous director will call rollBackToCommittedState(). If the FMU supports it, then this method will use fmiSetFMUstate() to restore the state to the state of the FMU at the time of the last postfire() (or initialize(), if postfire() has not yet been invoked).

If the FMU does not support rolling back (indicated by the canGetAndSetFMUstate element in the XML file), then this actor assumes that the FMU is stateless and hence can be rolled back without any particular action. This may not be a good assumption, so it issues a warning.

Many tools that export FMUs fail to correctly declare when outputs do not depend on inputs. For this reason, this actor provides each output port with a "dependencies" parameter. If this parameter is left blank, then the dependencies are determined by the FMU's modelDescription.xml file. Otherwise, if this parameter contains a space-separated list of names of input ports, then the output port depends directly on those named input ports. If this parameter contains the string "none", then the output port depends directly on none of the input ports. If contains the string "all", then this output port depends on all input ports. Although the FMI standard is ambiguous, we infer dependency to mean that the value of an output at time t depends on the input at time t. It is irrelevant whether it depends on the input at earlier times.

Note that if the display name of a port is set, display name is used in as the name of the FMU scalar variable instead of the port name. This is useful in case FMU scalar variable names contain a period, because periods are not allowed in port names.

Since:

Ptolemy II 10.0

Version:

$Id: FMU.java 70402 2014-10-23 00:52:20Z cxh $, $Id: FMU.java 70402 2014-10-23 00:52:20Z cxh $

Author:

Christopher Brooks, Michael Wetter, Edward A. Lee,

Accepted Rating:

Red (cxh)

Proposed Rating:

Red (cxh)

Nested Class Summary

Nested classes/interfaces inherited from class ptolemy.kernel.Entity

Entity.ContainedObjectsIterator

Field Summary

Fields

Modifier and Type	Field and Description
protected com.sun.jna.Pointer	_fmiComponent The FMI component created by the modelIdentifier_fmiInstantiateSlave() method.
protected FMIModelDescription	_fmiModelDescription A representation of the fmiModelDescription element of a Functional Mock-up Unit (FMU) file.
protected double	_fmiVersion The version of FMI that the FMU declares it is compatible with, converted to a double for easy comparison.
protected java.nio.DoubleBuffer	_states For model exchange, the FMU state variables.
StringParameter	fmiVersion The FMI version of the FMU.
FileParameter	fmuFile The Functional Mock-up Unit (FMU) file.
Parameter	modelExchange If true, then this FMU is for model exchange rather than co-simulation.
Parameter	persistentInputs If true, then previously received input values will be re-used on subsequent firings where inputs are absent.
Parameter	suppressWarnings If true, suppress warnings about the FMU not being able to roll back.
Parameter	visible If true, indicate to the FMU (if it supports it) that it is allowed to create displays and otherwise interact with the user.

Fields inherited from class ptolemy.actor.TypedAtomicActor

_typesValid

Fields inherited from class ptolemy.actor.AtomicActor

_actorFiringListeners, _initializables, _notifyingActorFiring, _stopRequested

Fields inherited from class ptolemy.kernel.util.NamedObj

_changeListeners, _changeLock, _changeRequests, _debugging, _debugListeners, _deferChangeRequests, _elementName, _isPersistent, _verbose, _workspace, ATTRIBUTES, CLASSNAME, COMPLETE, CONTENTS, DEEP, FULLNAME, LINKS

Fields inherited from interface ptolemy.actor.Executable

COMPLETED, NOT_READY, STOP_ITERATING

Constructor Summary

Constructors

Constructor and Description
FMU(CompositeEntity container, java.lang.String name) Construct an actor with the given container and name.

Method Summary

Modifier and Type	Method and Description
protected boolean	_checkEventIndicators() Return true if we are not in the first firing and the sign of some event indicator has changed.
protected void	_debugToStdOut(java.lang.String message) Print the debug message to stdout and flush stdout.
protected void	_fmiCompletedIntegratorStep(boolean eventOccurred) For model exchange, complete the integrator step, and if the FMU indicates that fmiEventUpdate() should be called, call it.
protected double	_fmiDoStep(Time newTime, int newMicrostep) Advance from the last firing time or last commit time to the specified time and microstep by calling fmiDoStep(), if necessary.
protected void	_fmiFreeInstance() Free the instance of the FMU.
protected double[]	_fmiGetDerivatives() Return the derivatives of the continuous states provided by the FMU.
protected void	_fmiInitialize() Invoke _fmiInitialize() (for model exchange) or _fmiInitializeSlave() (for co-simulation) on the FMU.
protected void	_fmiSetContinuousStates(double[] values) For model exchange, set the continuous states of the FMU to the specified array.
protected void	_fmiSetTime(Time time) Set the time of the FMU to the specified time.
protected static java.lang.String	_fmiStatusDescription(int fmiStatus) Return a string describing the specified fmiStatus.
protected void	_fmiTerminate() Terminate the FMU.
protected void	_freeFMUState() Free the memory recording FMU state, if the canGetAndSetFMUstate capability flag for the FMU is true.
protected double	_getStepSize() Return the current step size.
protected void	_recordFMUState() Record the current FMU state.
protected void	_requestRefiringIfNecessary() If the FMU can provide a maximum step size, query for that maximum step size and call fireAt() to ensure that the FMU is invoked at the specified time.
protected void	_restoreFMUState() Restore the current FMU state to match that most recently recorded, if the canGetAndSetFMUstate capability flag for the FMU is true.
protected void	_setFMUScalarVariable(FMIScalarVariable scalar, Token token) Set a scalar variable of the FMU to the value of a Ptolemy token.
protected void	_setParameter(Parameter parameter, FMIScalarVariable scalar) Set a Ptolemy II Parameter to the value of a FMI ScalarVariable.
protected boolean	_skipIfKnown() Return true if outputs are skipped if known.
boolean	advance(Time time, int microstep) Advance to the specified time.
void	attributeChanged(Attribute attribute) If the specified attribute is fmuFile, then unzip the file and load in the .xml file, creating and deleting parameters as necessary.
void	declareDelayDependency() Set the dependency between all output ports and all input ports of this actor.
void	fire() Invoke fmiDoStep() of the slave FMU, if necessary to catch up to current time, and then set the (known) inputs of the FMU and retrieve and send out any outputs for which all inputs on which the output depends are known.
static void	importFMU(java.lang.Object originator, FileParameter fmuFileParameter, NamedObj context, double x, double y, boolean modelExchange) Import a FMUFile.
void	initialize() Initialize this FMU wrapper.
boolean	isStepSizeAccurate() Return whether the most recent call to fmiDoStep() succeeded.
boolean	isStrict() Return false if any output has been found that not depend directly on an input.
boolean	postfire() Override the base class to record the current time as the last commit time.
void	preinitialize() Instantiate the slave FMU component.
double	refinedStepSize() Return suggested refined step size, if the FMU has provided one.
void	rollBackToCommittedState() Roll back to committed state, if the FMU has asserted canGetAndSetFMUstate in the XML file and has provided the methods to set and restore state.
double	suggestedStepSize() Return the suggested next step size.
void	wrapup() Terminate and free the slave fmu.

Methods inherited from class ptolemy.actor.TypedAtomicActor

_containedTypeConstraints, _customTypeConstraints, _defaultTypeConstraints, _fireAt, _fireAt, attributeTypeChanged, clone, clone, isBackwardTypeInferenceEnabled, newPort, typeConstraintList, typeConstraints

Methods inherited from class ptolemy.actor.AtomicActor

_actorFiring, _actorFiring, _declareDelayDependency, addActorFiringListener, addInitializable, connectionsChanged, createReceivers, getCausalityInterface, getDirector, getExecutiveDirector, getManager, inputPortList, isFireFunctional, iterate, newReceiver, outputPortList, prefire, pruneDependencies, recordFiring, removeActorFiringListener, removeDependency, removeInitializable, setContainer, stop, stopFire, terminate

Methods inherited from class ptolemy.kernel.ComponentEntity

_adjustDeferrals, _checkContainer, _getContainedObject, _propagateExistence, getContainer, instantiate, isAtomic, isOpaque, moveDown, moveToFirst, moveToIndex, moveToLast, moveUp, propagateExistence, setName

Methods inherited from class ptolemy.kernel.Entity

_addPort, _description, _exportMoMLContents, _removePort, _validateSettables, connectedPortList, connectedPorts, containedObjectsIterator, getAttribute, getPort, getPorts, linkedRelationList, linkedRelations, portList, removeAllPorts, setClassDefinition, uniqueName

Methods inherited from class ptolemy.kernel.InstantiableNamedObj

_setParent, exportMoML, getChildren, getElementName, getParent, getPrototypeList, isClassDefinition, isWithinClassDefinition

Methods inherited from class ptolemy.kernel.util.NamedObj

_addAttribute, _adjustOverride, _attachText, _cloneFixAttributeFields, _containedDecorators, _copyChangeRequestList, _debug, _debug, _debug, _debug, _debug, _executeChangeRequests, _getIndentPrefix, _isMoMLSuppressed, _markContentsDerived, _notifyHierarchyListenersAfterChange, _notifyHierarchyListenersBeforeChange, _propagateValue, _removeAttribute, _splitName, _stripNumericSuffix, addChangeListener, addDebugListener, addHierarchyListener, attributeDeleted, attributeList, attributeList, decorators, deepContains, depthInHierarchy, description, description, event, executeChangeRequests, exportMoML, exportMoML, exportMoML, exportMoML, exportMoMLPlain, getAttribute, getAttributes, getChangeListeners, getClassName, getDecoratorAttribute, getDecoratorAttributes, getDerivedLevel, getDerivedList, getDisplayName, getFullName, getModelErrorHandler, getName, getName, getSource, handleModelError, isDeferringChangeRequests, isOverridden, isPersistent, lazyContainedObjectsIterator, message, notifyOfNameChange, propagateValue, propagateValues, removeAttribute, removeChangeListener, removeDebugListener, removeHierarchyListener, requestChange, setClassName, setDeferringChangeRequests, setDerivedLevel, setDisplayName, setModelErrorHandler, setPersistent, setSource, sortContainedObjects, toplevel, toString, validateSettables, workspace

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface ptolemy.actor.Actor

createReceivers, getCausalityInterface, getDirector, getExecutiveDirector, getManager, inputPortList, newReceiver, outputPortList

Methods inherited from interface ptolemy.actor.Executable

isFireFunctional, iterate, prefire, stop, stopFire, terminate

Methods inherited from interface ptolemy.actor.Initializable

addInitializable, removeInitializable

Methods inherited from interface ptolemy.kernel.util.Nameable

description, getContainer, getDisplayName, getFullName, getName, getName, setName

Methods inherited from interface ptolemy.kernel.util.Derivable

getDerivedLevel, getDerivedList, propagateValue

Field Detail

fmiVersion

public StringParameter fmiVersion

The FMI version of the FMU. This is a string that defaults to "1.0" if the FMU file does not specify a version, and otherwise is the version specified in the file.

fmuFile

public FileParameter fmuFile

The Functional Mock-up Unit (FMU) file. The FMU file is a zip file that contains a file named "modelDescription.xml" and any necessary shared libraries. The file is read when this actor is instantiated or when the file name changes. The initial default value is "fmuImport.fmu".

modelExchange

public Parameter modelExchange

If true, then this FMU is for model exchange rather than co-simulation. This is a boolean that defaults to false. The value of this parameter gets determined when FMU is imported. This parameter is set to expert mode because normally a user should not be allowed to change it.

persistentInputs

public Parameter persistentInputs

If true, then previously received input values will be re-used on subsequent firings where inputs are absent. If there are no previously received input values, then the value used will be whatever default the FMU has for the corresponding input variable. If false (the default), then an exception will be thrown if an input is absent on any firing.

suppressWarnings

public Parameter suppressWarnings

If true, suppress warnings about the FMU not being able to roll back. It is reasonable to set this to true if you know that the FMU can be executed at an earlier time than it was previously executed. This is safe, for example, if the FMU is stateless. This is a boolean that defaults to false.

visible

public Parameter visible

If true, indicate to the FMU (if it supports it) that it is allowed to create displays and otherwise interact with the user. This is a boolean that defaults to false.

_fmiComponent

protected com.sun.jna.Pointer _fmiComponent

The FMI component created by the modelIdentifier_fmiInstantiateSlave() method.

_fmiModelDescription

protected FMIModelDescription _fmiModelDescription

A representation of the fmiModelDescription element of a Functional Mock-up Unit (FMU) file.

_fmiVersion

protected double _fmiVersion

The version of FMI that the FMU declares it is compatible with, converted to a double for easy comparison.

_states

protected java.nio.DoubleBuffer _states

For model exchange, the FMU state variables.

Constructor Detail

FMU

public FMU(CompositeEntity container,
           java.lang.String name)
    throws NameDuplicationException,
           IllegalActionException

Construct an actor with the given container and name.

Parameters:

container - The container.

name - The name of this actor.

Throws:

IllegalActionException - If the actor cannot be contained by the proposed container.

NameDuplicationException - If the container already has an actor with this name.

Method Detail

advance

public boolean advance(Time time,
                       int microstep)
                throws IllegalActionException

Advance to the specified time.

Specified by:

advance in interface Advanceable

Parameters:

time - The time to advance.

microstep - The microstep to advance.

Returns:

True if advancement to the specified time succeeds.

Throws:

IllegalActionException - If an error occurs advancing time.

attributeChanged

public void attributeChanged(Attribute attribute)
                      throws IllegalActionException

If the specified attribute is fmuFile, then unzip the file and load in the .xml file, creating and deleting parameters as necessary.

Overrides:

attributeChanged in class NamedObj

Parameters:

attribute - The attribute that has changed.

Throws:

IllegalActionException - If the specified attribute is fmuFile and the file cannot be opened or there is a problem creating or destroying the parameters listed in the file.

declareDelayDependency

public void declareDelayDependency()
                            throws IllegalActionException

Set the dependency between all output ports and all input ports of this actor. By default, each output port is assumed to have a dependency on all input ports. If the FMU explicitly declares input dependencies for a particular output, then then it only depends on those inputs that it declares.

Overrides:

declareDelayDependency in class AtomicActor<TypedIOPort>

Throws:

IllegalActionException - Not thrown in this base class, derived classes should throw this exception if the delay dependency cannot be computed.

See Also:

AtomicActor.getCausalityInterface(), AtomicActor._declareDelayDependency(IOPort, IOPort, double)

fire

public void fire()
          throws IllegalActionException

Invoke fmiDoStep() of the slave FMU, if necessary to catch up to current time, and then set the (known) inputs of the FMU and retrieve and send out any outputs for which all inputs on which the output depends are known.

Specified by:

fire in interface Executable

Overrides:

fire in class AtomicActor<TypedIOPort>

Throws:

IllegalActionException - If FMU indicates a failure.

initialize

public void initialize()
                throws IllegalActionException

Initialize this FMU wrapper. For co-simulation, this initializes the FMU. For model exchange, it does not, because for model exchange, the inputs at the start time need to be provided prior to initialization. Initialization will therefore occur in the first invocation of fire().

Specified by:

initialize in interface Initializable

Overrides:

initialize in class AtomicActor<TypedIOPort>

Throws:

IllegalActionException - If the slave FMU cannot be initialized.

importFMU

public static void importFMU(java.lang.Object originator,
                             FileParameter fmuFileParameter,
                             NamedObj context,
                             double x,
                             double y,
                             boolean modelExchange)
                      throws IllegalActionException,
                             java.io.IOException

Import a FMUFile.

Parameters:

originator - The originator of the change request.

fmuFileParameter - The .fmuFile

context - The context in which the FMU actor is created.

x - The x-axis value of the actor to be created.

y - The y-axis value of the actor to be created.

modelExchange - If true, import for model exchange (vs. co-simulation).

Throws:

IllegalActionException - If there is a problem instantiating the actor.

java.io.IOException - If there is a problem parsing the fmu file.

isStepSizeAccurate

public boolean isStepSizeAccurate()

Return whether the most recent call to fmiDoStep() succeeded. This will return false if fmiDoStep() discarded the step. This method assumes that if a director calls this method, then it will fully handle the discarded step. If this method is not called, then the next call to postfire() will throw an exception.

Specified by:

isStepSizeAccurate in interface ContinuousStepSizeController

Returns:

True if the current step is accurate.

isStrict

public boolean isStrict()

Return false if any output has been found that not depend directly on an input.

Specified by:

isStrict in interface Executable

Overrides:

isStrict in class AtomicActor<TypedIOPort>

Returns:

False if this actor can be fired without all inputs being known.

postfire

public boolean postfire()
                 throws IllegalActionException

Override the base class to record the current time as the last commit time.

Specified by:

postfire in interface Executable

Overrides:

postfire in class AtomicActor<TypedIOPort>

Returns:

True if execution can continue into the next iteration.

Throws:

IllegalActionException - Not thrown in this base class.

preinitialize

public void preinitialize()
                   throws IllegalActionException

Instantiate the slave FMU component.

Specified by:

preinitialize in interface Initializable

Overrides:

preinitialize in class AtomicActor<TypedIOPort>

Throws:

IllegalActionException - if it cannot be instantiated.

refinedStepSize

public double refinedStepSize()
                       throws IllegalActionException

Return suggested refined step size, if the FMU has provided one.

Specified by:

refinedStepSize in interface ContinuousStepSizeController

Returns:

The suggested refined step size.

Throws:

IllegalActionException - If the step size cannot be further refined.

rollBackToCommittedState

public void rollBackToCommittedState()
                              throws IllegalActionException

Roll back to committed state, if the FMU has asserted canGetAndSetFMUstate in the XML file and has provided the methods to set and restore state. Otherwise, issue a warning.

Specified by:

rollBackToCommittedState in interface ContinuousStatefulComponent

Throws:

IllegalActionException - If the rollback attempts to go back further than the last committed time.

suggestedStepSize

public double suggestedStepSize()
                         throws IllegalActionException

Return the suggested next step size. This method returns 0.0 if the previous invocation of fmiDoStep() was discarded, in order to force a zero-time integration step after an event is detected by the FMU. Otherwise, return Double.MAC_VALUE. return java.lang.Double.MAX_VALUE.

Specified by:

suggestedStepSize in interface ContinuousStepSizeController

Returns:

The suggested next step size.

Throws:

IllegalActionException - If an actor suggests an illegal step size.

wrapup

public void wrapup()
            throws IllegalActionException

Terminate and free the slave fmu.

Specified by:

wrapup in interface Initializable

Overrides:

wrapup in class AtomicActor<TypedIOPort>

Throws:

IllegalActionException - If the slave fmu cannot be terminated or freed.

_checkEventIndicators

protected boolean _checkEventIndicators()
                                 throws IllegalActionException

Return true if we are not in the first firing and the sign of some event indicator has changed.

Returns:

True if a state event has occurred.

Throws:

IllegalActionException - If the fmiGetEventIndicators function is missing, or if calling it does not return fmiOK.

_debugToStdOut

protected void _debugToStdOut(java.lang.String message)

Print the debug message to stdout and flush stdout. This is useful for tracking down segfault problems. To use this, right click on the FMU actor and select "Listen to Actor". The logging messages will appear on stdout and in the listener window.

Parameters:

message - The message to be displayed.

_fmiCompletedIntegratorStep

protected void _fmiCompletedIntegratorStep(boolean eventOccurred)
                                    throws IllegalActionException

For model exchange, complete the integrator step, and if the FMU indicates that fmiEventUpdate() should be called, call it.

Parameters:

eventOccurred - True if a time event or state event has occurred and fmiEventUpdate should be called.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_fmiDoStep

protected double _fmiDoStep(Time newTime,
                            int newMicrostep)
                     throws IllegalActionException

Advance from the last firing time or last commit time to the specified time and microstep by calling fmiDoStep(), if necessary. This method is for co-simulation only. Such an advance is necessary if the newTime is not equal to the last firing time, or if it is equal and the newMicrostep is greater than the last firing microstep. If the step size is rejected, then return a new suggested step size, which is either half the specified step size, or, if the FMU supports it, the last successful time reported by the FMU. As a side effect, if the time advance is successful, then the _lastFireTime and _lastFireMicrostep are updated to match the arguments, indicating that the FMU has advanced to that time.

Parameters:

newTime - The time to advance to.

newMicrostep - The microstep to advance to.

Returns:

A revised suggested step size, or -1.0 if the step size was accepted by the FMU.

Throws:

IllegalActionException - If fmiDoStep() returns anything other than fmiDiscard or fmiOK.

_fmiFreeInstance

protected void _fmiFreeInstance()
                         throws IllegalActionException

Free the instance of the FMU.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_fmiGetDerivatives

protected double[] _fmiGetDerivatives()
                               throws IllegalActionException

Return the derivatives of the continuous states provided by the FMU.

Returns:

The derivatives of the FMU.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_fmiInitialize

protected void _fmiInitialize()
                       throws IllegalActionException

Invoke _fmiInitialize() (for model exchange) or _fmiInitializeSlave() (for co-simulation) on the FMU. In the case of model exchange, this method also checks for a returned next event time and calls fireAt() on the director if a next event time is returned. In the case of co-simulation, if the FMU provides a maximum step size, get that from the FMU and call fireAt() as well.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_fmiSetContinuousStates

protected void _fmiSetContinuousStates(double[] values)
                                throws IllegalActionException

For model exchange, set the continuous states of the FMU to the specified array.

Parameters:

values - The values to assign to the states.

Throws:

IllegalActionException - If the length of the array does not match the number of continuous states, or if the FMU does not return fmiOK.

_fmiSetTime

protected void _fmiSetTime(Time time)
                    throws IllegalActionException

Set the time of the FMU to the specified time.

Parameters:

time - The time.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_fmiStatusDescription

protected static java.lang.String _fmiStatusDescription(int fmiStatus)

Return a string describing the specified fmiStatus.

Parameters:

fmiStatus - The status returned by an FMI procedure.

Returns:

a String describing the status.

_fmiTerminate

protected void _fmiTerminate()
                      throws IllegalActionException

Terminate the FMU.

Throws:

IllegalActionException - If the FMU does not return fmiOK.

_freeFMUState

protected void _freeFMUState()
                      throws IllegalActionException

Free the memory recording FMU state, if the canGetAndSetFMUstate capability flag for the FMU is true. Otherwise, do nothing.

Throws:

IllegalActionException - If freeing the memory the state fails.

_getStepSize

protected double _getStepSize()
                       throws IllegalActionException

Return the current step size. If the director implements ContinuousStatefulDirector, then the value returned by currentStepSize() is returned. If the director is an instance of PeriodicDirector, then the value returned by periodValue() is returned.

Returns:

the current step size.

Throws:

IllegalActionException - If there is a problem getting the currentStepSize.

_recordFMUState

protected void _recordFMUState()
                        throws IllegalActionException

Record the current FMU state. For model exchange, this copies the FMU state into the variable _state using fmiGetContinuousStates(). For co-simulation, if the canGetAndSetFMUstate capability flag for the FMU is true, then it record the state by invoking fmiGetFMUstate(). If the capability flag is false, do nothing.

Throws:

IllegalActionException - If recording the state fails.

_requestRefiringIfNecessary

protected void _requestRefiringIfNecessary()
                                    throws IllegalActionException

If the FMU can provide a maximum step size, query for that maximum step size and call fireAt() to ensure that the FMU is invoked at the specified time.

Throws:

IllegalActionException - If the call to fireAt() throws it.

_restoreFMUState

protected void _restoreFMUState()
                         throws IllegalActionException

Restore the current FMU state to match that most recently recorded, if the canGetAndSetFMUstate capability flag for the FMU is true. Otherwise, do nothing.

Throws:

IllegalActionException - If there is no recorded state, or if restoring the state fails.

_setParameter

protected void _setParameter(Parameter parameter,
                             FMIScalarVariable scalar)
                      throws IllegalActionException

Set a Ptolemy II Parameter to the value of a FMI ScalarVariable.

Parameters:

parameter - The Ptolemy parameter to be set.

scalar - The FMI scalar variable that contains the value to be set

Throws:

IllegalActionException - If the scalar is of a type that is not handled.

_setFMUScalarVariable

protected void _setFMUScalarVariable(FMIScalarVariable scalar,
                                     Token token)
                              throws IllegalActionException

Set a scalar variable of the FMU to the value of a Ptolemy token.

Parameters:

scalar - the FMI scalar to be set.

token - the Ptolemy token that contains the value to be set.

Throws:

IllegalActionException - If the scalar is of a type that is not handled or if the type of the token does not match the type of the scalar.

_skipIfKnown

protected boolean _skipIfKnown()
                        throws IllegalActionException

Return true if outputs are skipped if known. A true value means that only a single output token will be produced in each iteration of this actor. A false value means that a sequence of output tokens may be produced. Generally, for domains that implement fixed-point semantics, such as Continuous and SR, the return value should be true. Otherwise it should be false. If the director is a ContinuousDirector, then return true. If the director is SDFDirector, then return false.

Returns:

the true if outputs that have been set are skipped.

Throws:

IllegalActionException - If there is a problem getting the currentStepSize.