OpenModelica

https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/
Admin
OpenModelica is an open-source Modelica environment providing an interactive computational platform...
Tokens:262,359
Snippets:3,532
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### OMSimulator Lua Interface Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

A comprehensive example demonstrating the setup and execution of a simulation using the OMSimulator Lua interface, including model creation, FMU instantiation, connections, and simulation control.

```lua
oms_setTempDirectory("./temp/")
oms_newModel("model")
oms_addSystem("model.root", oms_system_sc)

-- instantiate FMUs
oms_addSubModel("model.root.system1", "FMUs/System1.fmu")
oms_addSubModel("model.root.system2", "FMUs/System2.fmu")

-- add connections
oms_addConnection("model.root.system1.y", "model.root.system2.u")
oms_addConnection("model.root.system2.y", "model.root.system1.u")

-- simulation settings
oms_setResultFile("model", "results.mat")
oms_setStopTime("model", 0.1)
oms_setFixedStepSize("model.root", 1e-4)

oms_instantiate("model")
oms_setReal("model.root.system1.x_start", 2.5)

oms_initialize("model")
oms_simulate("model")
oms_terminate("model")
oms_delete("model")

```

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

### OpenModelica Scripting Interface Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Demonstrates the setup and execution of a simulation using the OpenModelica Scripting interface. This includes loading the library, creating a model, adding systems and submodels, defining connections, setting simulation parameters, and running the simulation.

```OpenModelicaScript
loadOMSimulator();
oms_setTempDirectory("./temp/");
oms_newModel("model");
oms_addSystem("model.root", OpenModelica.Scripting.oms_system.oms_system_sc);

// instantiate FMUs
oms_addSubModel("model.root.system1", "FMUs/System1.fmu");
oms_addSubModel("model.root.system2", "FMUs/System2.fmu");

// add connections
oms_addConnection("model.root.system1.y", "model.root.system2.u");
oms_addConnection("model.root.system2.y", "model.root.system1.u");

// simulation settings
oms_setResultFile("model", "results.mat");
oms_setStopTime("model", 0.1);
oms_setFixedStepSize("model.root", 1e-4);

oms_instantiate("model");
oms_setReal("model.root.system1.x_start", 2.5);

oms_initialize("model");
oms_simulate("model");
oms_terminate("model");
oms_delete("model");
unloadOMSimulator();
```

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

### Get Available Library Versions

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns a list of installed versions for a specified library.

```MetaModelica
function getAvailableLibraryVersions
  input TypeName libraryName;
  output String[:] librariesAndVersions;
end getAvailableLibraryVersions;

```

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

### GBODE Solver Configuration Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

This example shows how to configure the GBODE solver to use the 'rungekutta' method, which is a deprecated solver. Use this for migrating from older configurations.

```bash
old: -s=rungekutta
new: -s=gbode -gbm=rungekutta -gbctrl=const
```

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

### getStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Gets the start time from the model.

```APIDOC
## getStartTime

### Description
Get the start time from the model.

### Method Signature
```
startTime, status = oms.getStartTime(cref)
```
```

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

### OpenModelica Initialization Warnings

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

Example output from OpenModelica during model initialization, highlighting warnings about parameters with no values and fixed start values. These messages indicate potential issues or assumptions made during the initialization process.

```text
 "[/var/lib/jenkins1/ws/OpenModelica_master/build/lib/omlibrary/Modelica 4.1.0+maint.om/Mechanics/MultiBody/Parts/Body.mo:14:3-15:65:writable] Warning: Parameter body1.r_CM has no value, and is fixed during initialization (fixed=true), using available start value (start={0, 0, 0}) as default value.
[/var/lib/jenkins1/ws/OpenModelica_master/build/lib/omlibrary/Modelica 4.1.0+maint.om/Mechanics/MultiBody/Parts/Body.mo:14:3-15:65:writable] Warning: Parameter body2.r_CM has no value, and is fixed during initialization (fixed=true), using available start value (start={0, 0, 0}) as default value.
Warning: Assuming fixed start value for the following 2 variables:
         $STATESET2.x:VARIABLE(start = /*Real*/($STATESET2.A[1]) * $START.revolute1.phi + /*Real*/($STATESET2.A[2]) * $START.revolute2.phi fixed = true )  type: Real

```

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

### Python Script for System Identification Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

This Python script demonstrates system identification using the OMSysIdent library. It estimates parameters for a 'hello world' Modelica model by simulating it and using the generated data as measurements. Ensure OMSimulator and OMSysIdent are installed and accessible.

```python
from OMSimulator import OMSimulator
from OMSysIdent import OMSysIdent
import numpy as np

oms = OMSimulator()

oms.setLogFile("HelloWorld_cs_Fit_py.log")
oms.setTempDirectory("./HelloWorld_cs_Fit_py/")
oms.newModel("HelloWorld_cs_Fit")
oms.addSystem("HelloWorld_cs_Fit.root", oms.system_wc)
# oms.setTolerance("HelloWorld_cs_Fit.root", 1e-5)

# add FMU
oms.addSubModel("HelloWorld_cs_Fit.root.HelloWorld", "../resources/HelloWorld.fmu")

# create simodel for model
simodel = OMSysIdent("HelloWorld_cs_Fit")
# simodel.describe()

# Data generated from simulating HelloWorld.mo for 1.0s with Euler and 0.1s step size
kNumSeries = 1
kNumObservations = 11
data_time = np.array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
inputvars = []
measurementvars = ["root.HelloWorld.x"]
data_x = np.array([1, 0.9, 0.8100000000000001, 0.7290000000000001, 0.6561, 0.5904900000000001, 0.5314410000000001, 0.4782969000000001, 0.43046721, 0.387420489, 0.3486784401])

simodel.initialize(kNumSeries, data_time, inputvars, measurementvars)
# simodel.describe()

simodel.addParameter("root.HelloWorld.x_start", 0.5)
simodel.addParameter("root.HelloWorld.a", -0.5)
simodel.addMeasurement(0, "root.HelloWorld.x", data_x)
# simodel.describe()

simodel.setOptions_max_num_iterations(25)
simodel.solve("BriefReport")

status, state = simodel.getState()
# print('status: {0}; state: {1}').format(OMSysIdent.status_str(status), OMSysIdent.omsi_simodelstate_str(state))

status, startvalue1, estimatedvalue1 = simodel.getParameter("root.HelloWorld.a")
status, startvalue2, estimatedvalue2 = simodel.getParameter("root.HelloWorld.x_start")
# print('HelloWorld.a startvalue1: {0}; estimatedvalue1: {1}'.format(startvalue1, estimatedvalue1))
# print('HelloWorld.x_start startvalue2: {0}; estimatedvalue2: {1}'.format(startvalue2, estimatedvalue2))
is_OK1 = estimatedvalue1 > -1.1 and estimatedvalue1 < -0.9
is_OK2 = estimatedvalue2 > 0.9 and estimatedvalue2 < 1.1
print('HelloWorld.a estimation is OK: {0}'.format(is_OK1))
print('HelloWorld.x_start estimation is OK: {0}'.format(is_OK2))
```

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

### Install Package

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Installs a specified package, optionally with a version and exact match setting. Returns a boolean indicating the result.

```OpenModelica
function installPackage
  input TypeName pkg;
  input String version = "";
  input Boolean exactMatch = false;
  output Boolean result;
end installPackage;
```

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

### Example: Activating Multiple Variants in SSP

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Illustrates how to activate different variants within an SSP file. This example demonstrates duplicating variants and switching between them, including reactivating a previously activated variant.

```python
oms_newModel("model")
om_addSystem("model.root", "system_wc")
om_addSubModel("model.root.A", "A.fmu")
om_duplicateVariant("model", "varA") # varA will be the current variant
om_duplicateVariant("varA", "varB") # varB will be the current variant
om_activateVariant("varB", "varA") # Reactivate the variant varB to varA
om_activateVariant("varA", "model") # Reactivate the variant varA to model

```

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

### Install Package (Exact Match)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/packagemanager.html

Installs a specific version (e.g., '7.0.0') of a library, even if newer compatible versions are available. This includes all dependencies. Append getErrorString() for more information.

```modelica
installPackage("Buildings", "7.0.0", exactMatch = true)
```

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

### Set Simulation Start Time with oms_setStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Sets the start time for the simulation.

```c
status = oms_setStartTime(cref, startTime)
```

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

### Get Simulation Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the configured start time for the simulation model.

```python
startTime, status = oms.getStartTime(cref)
```

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

### getInstallationDirectoryPath

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns the installation directory path.

```APIDOC
## getInstallationDirectoryPath

### Description
Returns the installation directory path.

### Signature
```
function getInstallationDirectoryPath
  output String installationDirectoryPath;
end getInstallationDirectoryPath;
```
```

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

### Set Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Sets the start time of the simulation. Requires a component reference and the start time value.

```c
oms_status_enu_t oms_setStartTime(const char* cref, double startTime);
```

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

### Get Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the start time configured for the model.

```c
oms_status_enu_t oms_getStartTime(const char* cref, double* startTime);
```

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

### Get Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Use oms_getStartTime to retrieve the start time configured for the model. Returns the start time and a status code.

```c
startTime, status = oms_getStartTime(cref)

```

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

### Get Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the simulation start time configured for the model. Requires a model reference.

```OpenModelica
(startTime, status) := oms_getStartTime(cref);

```

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

### Install Package (Most Recent)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/packagemanager.html

Installs the most recent version of a specified library (e.g., Buildings) along with all its dependencies. Append getErrorString() for more information.

```modelica
installPackage("Buildings", "")
```

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

### Simulation Parameter Sweep Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Example demonstrating how to update parameters and re-run a simulation without recompiling the model.

```APIDOC
## Simulation Parameter Sweep

### Description
Following example shows how to update the parameters and re-run the simulation without compiling the model.

### Example
```
loadFile("BouncingBall.mo");
getErrorString();
// build the model once
buildModel(BouncingBall);
getErrorString();
for i in 1:3 loop
  // We update the parameter e start value from 0.7 to "0.7 + i".
  value := 0.7 + i;
  // call the generated simulation code to produce a result file BouncingBall%i%_res.mat
  system("./BouncingBall -override=e="+String(value)+" -r=BouncingBall" + String(i) + "_res.mat");
  getErrorString();
end for;
```

We used the BouncingBall.mo in the example above. The above example produces three result files each containing different start value for _e_ i.e., 1.7, 2.7, 3.7.
```

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

### setStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Sets the start time for the simulation.

```APIDOC
## setStartTime

### Description
Set the start time of the simulation.

### Method
Call

### Endpoint
oms.setStartTime(cref, startTime)

### Parameters
#### Path Parameters
- **cref** (string) - Required - Reference to the component or system.
- **startTime** (double) - Required - The start time of the simulation.
```

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

### Install OMSimulator using pip

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Recommended installation method for the OMSimulator Python package. Use the `--upgrade` flag to ensure you have the latest version.

```bash
> pip3 install OMSimulator --upgrade

```

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

### installPackage

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Installs a specified package with optional version and matching criteria.

```APIDOC
## installPackage

### Description
Installs a package.

### Signature
```
function installPackage
  input TypeName pkg;
  input String version = "";
  input Boolean exactMatch = false;
  output Boolean result;
end installPackage;
```
```

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

### Set Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Sets the start time of the simulation. Requires the simulation reference and the start time value.

```OpenModelica
function oms_setStartTime
  input String cref;
  input Real startTime;
  output Integer status;
end oms_setStartTime;

```

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

### Get Simulation Solutions (Default Filename)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Use getSolutions() without arguments to get string arrays of simulation variables available in the default result file.

```python
>>> omc.getSolutions() // method-1 returns string arrays of simulation variables for which results are available, the default result filename is taken
"time", "height", ""velocity", "der(height)", "der(velocity)", "c", "radius"


```

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

### Install Package (Backwards Compatible)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/packagemanager.html

Installs the most recent version of a library that is backwards-compatible with a specified version (e.g., '7.0.0'), including all its dependencies. Append getErrorString() for more information.

```modelica
installPackage("Buildings", "7.0.0")
```

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

### Set Simulation Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Defines the initial time for the simulation.

```python
status = oms.setStartTime(cref, startTime)
```

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

### Example: Creating and Exporting SSP with New Resources

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Demonstrates creating a new model, adding systems and connectors, creating new resources with a specified filename, setting parameter values, and exporting the SSP file.

```python
from OMSimulator import OMSimulator
ome = OMSimulator()
ome.newModel("newResources")

ome.addSystem("newResources.root", "system_wc")
ome.addConnector("newResources.root.Input1", oms.input, "signal_type_real")
ome.addConnector("newResources.root.Input2", oms.input, "signal_type_real")

## add Top level resources, the filename is provided using the colon suffix ":root.ssv"
ome.newResources("newResources.root:root.ssv")
ome.setReal("newResources.root.Input1", 10)
## export the ssp with new resources
ome.export("newResources", "newResources.ssp")
```

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

### Get Available Libraries

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns a list of all libraries that are currently available in the system.

```MetaModelica
function getAvailableLibraries
  output String[:] libraries;
end getAvailableLibraries;

```

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

### Get Start Time - oms_getStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Retrieves the start time of a model using its reference.

```OpenModelica
function oms_getStartTime
  input String cref;
  output Real startTime;
  output Integer status;
end oms_getStartTime;
```

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

### OpenModelica Initialization Command Line Options

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

Demonstrates how to load a model, set command-line options for detailed initialization output, and build the model in OpenModelica. Use '-d=initialization' to enable verbose initialization logging.

```python
>>> loadModel(Modelica);
>>> setCommandLineOptions("-d=initialization");
>>> buildModel(piston);

```

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

### Set Command Line Options and Simulate Model

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

This demonstrates how to set simulation options, specifically enabling detailed initialization output, and then simulate a model for a specified duration. This is useful for debugging initialization issues.

```OpenModelica
>>> setCommandLineOptions("-d=initialization");
>>> simulate(pistonInitialize, stopTime=2.0);
```

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

### OMMatlab Initialization and Basic Commands

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Demonstrates how to import the OMMatlab package, create a session object, and interact with the OpenModelica compiler using basic commands like getVersion, loadModel, and simulate.

```APIDOC
## OMMatlab Initialization and Basic Commands

### Description
This section shows how to initialize an OMMatlab session and perform basic operations.

### Usage
```matlab
import OMMatlab.*

omc = OMMatlab()

% Get OpenModelica version
omc.sendExpression("getVersion()")

% Load a Modelica model
omc.sendExpression("loadModel(Modelica)")

% Define and simulate a simple model
omc.sendExpression("model a Real s; equation s=sin(10*time); end a;")
omc.sendExpression("simulate(a)")

% Plot the simulation result
omc.sendExpression("plot(s)")
```

### API Calls
- `OMMatlab()`: Initializes a new OMMatlab session.
- `omc.sendExpression(expression)`: Sends a string expression to the OpenModelica compiler and returns the result as a string.
```

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

### Get Installation Directory Path

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Retrieves the installation directory path of the OpenModelica environment. This function has no inputs and returns a String.

```Modelica
function getInstallationDirectoryPath
  output String installationDirectoryPath;
end getInstallationDirectoryPath;

```

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

### Get OpenModelica Installation Directory Path

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/introduction.html

Retrieves the installation directory path for OpenModelica. This is useful for locating test models and documentation.

```shell
>>> getInstallationDirectoryPath()
"«OPENMODELICAHOME»/share/doc/omc/testmodels/"
```

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

### Get DrControl Installation Path

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omnotebook.html

This command retrieves the installation path for the DrControl tutorial directory within OpenModelica. It is useful for locating the tutorial files.

```python
getInstallationDirectoryPath() + "/share/omnotebook/drcontrol"
"«OPENMODELICAHOME»/share/omnotebook/drcontrol"
```

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

### Simulate Model and Get Results

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/plotting.html

Simulates the 'HelloWorld' model with specific parameters and outputs the results in CSV format. The simulation is limited to 5 intervals for brevity.

```OpenModelica
>>> simulate(HelloWorld, outputFormat="csv", startTime=0, stopTime=4, numberOfIntervals=5)
record SimulationResult
    resultFile = "«DOCHOME»/HelloWorld_res.csv",
    simulationOptions = "startTime = 0.0, stopTime = 4.0, numberOfIntervals = 5, tolerance = 1e-6, method = 'dassl', fileNamePrefix = 'HelloWorld', options = '', outputFormat = 'csv', variableFilter = '.*', cflags = '', simflags = ''",
    messages = "LOG_SUCCESS       | info    | The initialization finished successfully without homotopy method.
LOG_SUCCESS       | info    | The simulation finished successfully.
",
    timeFrontend = 0.004467483,
    timeBackend = 0.001438479,
    timeSimCode = 3.94621e-4,
    timeTemplates = 0.002280349,
    timeCompile = 0.285794739,
    timeSimulation = 0.01047209,
    timeTotal = 0.30495460300000005
end SimulationResult;

```

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

### Model Initialization with Fixed Start Values

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

This model extends a base 'piston' model and explicitly sets fixed start values and initial conditions for revolute joints. This is useful when a system has fewer degrees of freedom than joints and requires specific initialization.

```OpenModelica
model pistonInitialize
  extends piston(revolute1.phi.fixed = true, revolute1.phi.start = -1.221730476396031, revolute1.w.fixed = true, revolute1.w.start = 5);
equation
end pistonInitialize;
```

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

### Enable and Run Profiling

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/profiler.html

Enable profiling with a command-line option and then simulate the model. The results include detailed timing information.

```shell
>>> setCommandLineOptions("--profiling=blocks+html")
true
>>> simulate(ProfilingTest)
record SimulationResult
    resultFile = "«DOCHOME»/ProfilingTest_res.mat",
    simulationOptions = "startTime = 0.0, stopTime = 1.0, numberOfIntervals = 500, tolerance = 1e-6, method = 'dassl', fileNamePrefix = 'ProfilingTest', options = '', outputFormat = 'mat', variableFilter = '.*', cflags = '', simflags = ''",
    messages = "LOG_SUCCESS       | info    | The initialization finished successfully without homotopy method.
LOG_SUCCESS       | info    | The simulation finished successfully.
Warning: empty y range [1:1], adjusting to [0.99:1.01]
Warning: empty y range [1:1], adjusting to [0.99:1.01]
Warning: empty y range [1:1], adjusting to [0.99:1.01]
Warning: empty y range [1:1], adjusting to [0.99:1.01]
Warning: empty y range [1:1], adjusting to [0.99:1.01]
Warning: empty y range [1:1], adjusting to [0.99:1.01]
LOG_STDOUT        | info    | Time measurements are stored in ProfilingTest_prof.html (human-readable) and ProfilingTest_prof.xml (for XSL transforms or more details)
",
    timeFrontend = 0.0015648460000000002,
    timeBackend = 0.005052311,
    timeSimCode = 0.001210792,
    timeTemplates = 0.005610358,
    timeCompile = 0.32640423100000004,
    timeSimulation = 0.033744420000000004,
    timeTotal = 0.37365662800000005
end SimulationResult;
"Warning: There are nonlinear iteration variables with default zero start attribute found in NLSJac0. For more information set -d=initialization. In OMEdit Tools->Options->Simulation->Show additional information from the initialization process, in OMNotebook call setCommandLineOptions("-d=initialization").
Warning: The initial conditions are not fully specified. For more information set -d=initialization. In OMEdit Tools->Options->Simulation->Show additional information from the initialization process, in OMNotebook call setCommandLineOptions("-d=initialization").

```

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

### Object-Oriented OMSimulator Python API Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

An equivalent example to the basic API, showcasing the more object-oriented approach provided by the OMSimulator Python package. This version uses method chaining and direct attribute assignment for simulation setup.

```python
import OMSimulator as oms

om = OMSimulator()
om.setTempDirectory('./temp/')
model = om.newModel("model")
root = model.addSystem('root', oms.Types.System.SC)

# instantiate FMUs
root.addSubModel('system1', 'FMUs/System1.fmu')
root.addSubModel('system2', 'FMUs/System2.fmu')

# add connections
root.addConnection('system1.y', 'system2.u')
root.addConnection('system2.y', 'system1.u')

# simulation settings
model.resultFile = 'results.mat'
model.stopTime = 0.1
model.fixedStepSize = 1e-4

model.instantiate()
model.setReal('root.system1.x_start', 2.5)
#or system.setReal('system1.x_start', 2.5)

model.initialize()
model.simulate()
model.terminate()
model.delete()

```

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

### Basic OMSimulator Python API Example

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Demonstrates the basic usage of the OMSimulator Python interface for setting up and running a simulation. This includes creating a model, adding systems, instantiating FMUs, defining connections, setting simulation parameters, and executing the simulation.

```python
from OMSimulator import OMSimulator

oms = OMSimulator()
om = OMSimulator()
om.setTempDirectory("./temp/")
om.newModel("model")
om.addSystem("model.root", om.system_sc)

# instantiate FMUs
om.addSubModel("model.root.system1", "FMUs/System1.fmu")
om.addSubModel("model.root.system2", "FMUs/System2.fmu")

# add connections
om.addConnection("model.root.system1.y", "model.root.system2.u")
om.addConnection("model.root.system2.y", "model.root.system1.u")

# simulation settings
om.setResultFile("model", "results.mat")
om.setStopTime("model", 0.1)
om.setFixedStepSize("model.root", 1e-4)

om.instantiate("model")
om.setReal("model.root.system1.x_start", 2.5)

om.initialize("model")
om.simulate("model")
om.terminate("model")
om.delete("model")

```

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

### Get OpenModelica Version

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/introduction.html

Retrieves the current version of the OpenModelica Compiler (OMC). This command is helpful for verifying the installed version.

```shell
>>> getVersion()
"OMCompiler v1.27.0-dev.473+gfc5473e1719"
```

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

### Get Settings

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Retrieves general settings from the OpenModelica environment.

```OpenModelica
function getSettings
  output String settings;
end getSettings;
```

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

### Get Parameter Value (C API)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

The C API function `omsi_getParameter` retrieves the start and estimated values for a given parameter. It requires pointers to store the output values.

```c
oms_status_enu_t omsi_getParameter(void* simodel, const char* var, double* startvalue, double* estimatedvalue);
```

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

### Initialize System Identification Model for Simulation

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

The `simodel.initialize` function sets up the model for simulation. It requires the number of measurement series, time instants, input variable names, and measurement variable names.

```python
status = simodel.initalize(nSeries, time, inputvars, measurementvars)
```

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

### Get All Subtypes of a Class

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns a list of all classes that extend from a given class name, starting the lookup from a specified parent class. Options for qualified names and including partial classes are available.

```MetaModelica
function getAllSubtypeOf
  input TypeName className;
  input TypeName parentClass = $Code(AllLoadedClasses);
  input Boolean qualified = false "Not implemented";
  input Boolean includePartial = false;
  input Boolean sort = false;
  output TypeName classNames[:];
end getAllSubtypeOf;

```

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

### Get Estimated Parameter Value

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

Use `simodel.getParameter` to retrieve the start value and the estimated value of a parameter after the identification process. The C API `omsi_getParameter` requires pointers to store the output values.

```python
status, startvalue, estimatedvalue = simodel.getParameter(var)
```

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

### getSettings

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns some settings.

```APIDOC
## getSettings

### Description
Returns some settings.

### Signature
```
function getSettings
  output String settings;
end getSettings;
```
```

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

### Example: List Variants in an SSP File

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Demonstrates how to use OMSimulator functions to create a model with variants and then list the available variants using `oms_listVariants`.

```python
oms_newModel("model")
ome_addSystem("model.root", "system_wc")
ome_addSubModel("model.root.A", "A.fmu")
ome_duplicateVariant("model", "varA")
ome_duplicateVariant("varA", "varB")

ome_listVariants("varB")
```

```xml
<oms:Variants>
  <oms:variant name="model" />
  <oms:variant name="varB" />
  <oms:variant name="varA" />
</oms:Variants>
```

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

### Upgrade Installed Packages

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/packagemanager.html

Installs the latest available version for all currently installed packages. Set `installNewestVersions = true` to ensure the newest versions are installed. Append getErrorString() for more information.

```modelica
upgradeInstalledPackages(installNewestVersions = true)
```

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

### Simulate Model using simulate()

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Demonstrates three methods for simulating a model: using default results, specifying a result file, or providing simulation flags.

```matlab
>>> omc.simulate() // method-1 default result file name will be used
```

```matlab
>>> omc.simulate("tmpbouncingBall.mat") // method-2 resultfile name provided by users
```

```matlab
>>> omc.simulate([],"-noEventEmit -noRestart -override=e=0.3,g=9.71") // method-3 simulationflags provided by users, since matlab does not support keyword argument we skip argument1 result file with empty list
```

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

### Get Help for OpenModelica Compiler (omc)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/introduction.html

Use the --help flag to display command-line options and usage information for the OpenModelica compiler. This is useful for understanding available parameters and syntax.

```bash
$ omc --help
OpenModelica Compiler OMCompiler v1.27.0-dev.473+gfc5473e1719
Copyright © 2019 Open Source Modelica Consortium (OSMC)
Distributed under OMSC-PL and GPL, see www.openmodelica.org

Usage: omc [Options] (Model.mo | Script.mos) [Libraries | .mo-files]
* Libraries: Fully qualified names of libraries to load before processing Model or Script.
... 
Documentation is available in the built-in package OpenModelica.Scripting or
online <https://build.openmodelica.org/Documentation/OpenModelica.Scripting.html>.

```

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

### Define Start Value for a Variable

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/solving.html

This syntax defines a start value for a variable, which can be a real number or an expression. The `fixed = true` attribute indicates that this start value is assumed to be fixed during initialization.

```OpenModelica
$STATESET1.x:VARIABLE(start = /*Real*/($STATESET1.A[1]) * $START.revolute1.w + /*Real*/($STATESET1.A[2]) * $START.revolute2.w fixed = true )  type: Real
```

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

### Set Simulation Start Time

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Defines the starting time for the simulation.

```OpenModelica Scripting
status := oms_setStartTime(cref, startTime);
```

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

### instantiate

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Instantiates a given composite model, preparing it for simulation.

```APIDOC
## instantiate

### Description
Instantiates a given composite model.

### Method Signature
```
status = oms.instantiate(cref)
```
```

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

### Describe System Identification Model Summary

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

Call `simodel.describe` to print a summary of the current system identification model configuration and status.

```python
status = simodel.describe()
```

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

### Set Initialization XML Start Value

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Sets the start value for a variable within an initialization file used for simulations. Specify the input file, variable name, start value, and output file.

```OpenModelica
function setInitXmlStartValue
  input String fileName;
  input String variableName;
  input String startValue;
  input String outputFile;
  output Boolean success = false;
end setInitXmlStartValue;

```

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

### Set Simulation Options using setSimulationOptions()

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Shows how to set simulation options like stop time and tolerance using an array of string assignments.

```matlab
>>> omc.setSimulationOptions(["stopTime=2.0","tolerance=1e-08"])
```

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

### Specifying Initial Conditions with Attributes

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/porting.html

Use 'start' and 'fixed = true' attributes for variables to define initial conditions directly.

```modelica
parameter Real x_start = 10;
parameter Real v_start = 2.5;
Real x(start = x_start, fixed = true);
discrete Real v(start = v_start, fixed = true);
Integer i(start = 2, fixed = true);
```

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

### Get Parameters in OpenModelica (Struct)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Use getParameters() without arguments to get a struct containing all model parameters and their values.

```python
>>> omc.getParameters()  // method-1
struct with fields:
        e: '0.7'
        g: '9.810000000000001'


```

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

### Example: Create Multi-Variant Model

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Demonstrates the creation of a multi-variant model using OMSimulator APIs. This includes adding systems, sub-models, setting parameters, duplicating variants, and exporting the final multi-variant SSP.

```c
oms_newModel("model")
oms_addSystem("model.root", "system_wc")
oms_addSubModel("model.root.A", "A.fmu")
oms_setReal("model.root.A.param1", "10")
oms_duplicateVariant("model", "varB")
oms_addSubModel("varB.root.B" ,"B.fmu")
oms_setReal("varB.root.A.param2", "20")
oms_export("varB", "variant.ssp")
```

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

### getSimulationOptions

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns simulation options like startTime, stopTime, tolerance, and interval based on the experiment annotation.

```APIDOC
## getSimulationOptions

### Description
Returns the startTime, stopTime, tolerance, and interval based on the experiment annotation.

### Signature
```
function getSimulationOptions
  input TypeName name;
  input Real defaultStartTime = 0.0;
  input Real defaultStopTime = 1.0;
  input Real defaultTolerance = 1e-6;
  input Integer defaultNumberOfIntervals = 500 "May be overridden by defining defaultInterval instead";
  input Real defaultInterval = 0.0 "If = 0.0, then numberOfIntervals is used to calculate the step size";
  output Real startTime;
  output Real stopTime;
  output Real tolerance;
  output Integer numberOfIntervals;
  output Real interval;
end getSimulationOptions;
```
```

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

### Get Continuous Variables in OpenModelica (Struct)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Use getContinuous() without arguments to get a struct containing all continuous variables and their current values.

```python
>>> omc.getContinuous() // method-1, returns struct of continuous variable
struct with fields:
  h     : '1.0'
  v     : ''
  der_h_: ''
  der_v_: ''


```

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

### Set Installation Directory Path

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Sets the OPENMODELICAHOME environment variable, which specifies the installation directory of OpenModelica. This is crucial for locating necessary files and executables.

```OpenModelica
function setInstallationDirectoryPath
  input String installationDirectoryPath;
  output Boolean success;
end setInstallationDirectoryPath;

```

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

### Get Variable Step Size Parameters

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the initial, minimum, and maximum step size parameters for variable step size simulations.

```c
initialStepSize, minimumStepSize, maximumStepSize, status = oms_getVariableStepSize(cref)
```

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

### Get Specific Continuous Variables

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ompython.html

Retrieves the values for a specified list of continuous variables. Use this to get the current state of particular dynamic variables.

```python
>>> mod.getContinuous(["velocity","height"]) // method-2, get specific variable value information
(-1.825929609047952, 0.65907039052943617)
```

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

### Get Simulation Solutions (Custom Filename)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Use getSolutions() with a custom result filename to get string arrays of simulation variables available in that file.

```python
>>> omc.getSolutions([],[ "c:/tmpbouncingBall.mat"]) // method-2 returns string arrays of simulation variables for which results are available , the resulfile location is provided by user
"time", "height", "velocity", "der(height)", "der(velocity)", "c", "radius"


```

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

### initialize

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Initializes a composite model.

```APIDOC
## initialize

### Description
Initializes a composite model.

### Method
status := oms_initialize(cref);

### Parameters
#### Path Parameters
- **cref** (any) - Required - Reference to the model.

### Response
#### Success Response
- **status** (integer) - Indicates success or failure of the operation.
```

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

### Get Variable Step Size Parameters

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Fetches the initial, minimum, and maximum step size parameters for variable step size simulation.

```python
initialStepSize, minimumStepSize, maximumStepSize, status = oms.getVariableStepSize(cref)
```

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

### Get Linearization Options using getLinearizationOptions()

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Retrieves linearization options. The first method gets all options, while the second retrieves specific options like startTime and stopTime.

```matlab
>>> omc.getLinearizationOptions()  // method-1
```

```matlab
>>> omc.getLinearizationOptions(["startTime","stopTime"]) // method-2
"0.0", "1.0"
```

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

### Simulate Model (Default)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ompython.html

Simulates the model using default settings and the default result file name. This is the simplest way to run a simulation.

```python
>>> mod.simulate() // method-1 default result file name will be used

```

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

### initialize

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

Initializes a given composite model, placing it in simulation mode.

```APIDOC
## initialize (Python)

### Description
This function initializes a given composite model. After this call, the model is in simulation mode.

### Parameters
- **nSeries** (int) - Number of measurement series.
- **time** (numpy.array) - Array of measurement/input time instants.
- **inputvars** (list of str) - List of names of input variables (empty list if none).
- **measurementvars** (list of str) - List of names of observed measurement variables.

### Returns
- **status** (int) - The C-API status code (oms_status_enu_t).

### Example
```python
status = simodel.initalize(nSeries, time, inputvars, measurementvars)
```
```

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

### Get Element Modifier Value - OpenModelica Scripting

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Fetches the binding equation for a specific element's modifier. This function is used to get the actual value or definition of a modifier.

```OpenModelica
function getElementModifierValue
  input TypeName className;
  input TypeName modifier;
  output String value;
end getElementModifierValue;

```

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

### Get Package Uses

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns a list of libraries (uses) that a given package depends on. The output is a 2D array of strings.

```OpenModelica
function getUses
  input TypeName pack;
  output String[:, :] uses;
end getUses;
```

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

### Get Fixed Step Size

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Use oms_setFixedStepSize to get the fixed step size of a system. This can be used for communication step size in co-simulation or integrator step size in model exchange.

```c
stepSize, status = oms_setFixedStepSize(cref)

```

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

### Accessing Classes in Partial Packages

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/porting.html

Illustrates how to correctly access classes (like functions) defined in partial packages, demonstrating valid and invalid approaches for simulation.

```modelica
package TestPartialPackage
  partial package PartialPackage
    function f
      input Real x;
      output Real y;
    algorithm
      y := 2*x;
    end f;
  end PartialPackage;

  package RegularPackage
    extends PartialPackage;
    model A
      Real x = time;
    end A;
  end RegularPackage;

  model M1
    package P = PartialPackage;
    Real x = P.f(time);
  end M1;

  model M2
    extends M1(redeclare package P = RegularPackage);
  end M2;

  model M3
    encapsulated package LocalPackage
      import TestPartialPackage.PartialPackage;
      extends PartialPackage;
    end LocalPackage;
    package P = LocalPackage;
    Real x = P.f(time);
  end M3;
end TestPartialPackage;

```

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

### Get Simulation Options

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Retrieves simulation parameters like startTime, stopTime, tolerance, and interval. Allows specifying default values for these parameters.

```OpenModelica
function getSimulationOptions
  input TypeName name;
  input Real defaultStartTime = 0.0;
  input Real defaultStopTime = 1.0;
  input Real defaultTolerance = 1e-6;
  input Integer defaultNumberOfIntervals = 500 "May be overridden by defining defaultInterval instead";
  input Real defaultInterval = 0.0 "If = 0.0, then numberOfIntervals is used to calculate the step size";
  output Real startTime;
  output Real stopTime;
  output Real tolerance;
  output Integer numberOfIntervals;
  output Real interval;
end getSimulationOptions;
```

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

### Get Model Parameters

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/ommatlab.html

Demonstrates how to retrieve model parameters using the getParameters() method. This method can be called without arguments to get all parameters, or with a string or array of strings to query specific parameters.

```matlab
>>> omc.getParameters()
```

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

### Create New System Identification Model (C API)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

Creates a new, empty model instance for parameter estimation in C. Returns a void pointer to the newly created model.

```c
void* omsi_newSysIdentModel(const char* ident);
```

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

### Export SSV Template for FMU Signals

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Exports signals with start values from FMUs to an SSV file. This function can be applied to a top-level model or an individual FMU component to extract signal start values.

```python
status = oms.exportSSVTemplate(cref, filename)
```

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

### Export SSV Template

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Use oms_exportSSVTemplate to export signal start values from FMUs to an SSV file. This function can be applied to a top-level model or an individual FMU component, exporting their respective start values.

```c
status = oms_exportSSVTemplate(cref, filename)

```

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

### upgradeInstalledPackages

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Upgrades installed packages.

```APIDOC
## upgradeInstalledPackages

### Description
Upgrades installed packages.

### Parameters
- **installNewestVersions** (Boolean) - Optional - Defaults to true.

### Output
- **result** (Boolean)

### Signature
```
function upgradeInstalledPackages
  input Boolean installNewestVersions = true;
  output Boolean result;
end upgradeInstalledPackages;
```
```

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

### enableNewInstantiation

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Enables the new instantiation mechanism.

```APIDOC
## enableNewInstantiation

### Description
Enables the new (default) instantiation.

### Function Signature
```
function enableNewInstantiation
  output Boolean success;
end enableNewInstantiation;
```
```

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

### getReal

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Get real value.

```APIDOC
## getReal

### Description
Get real value.

### Method
(value, status) := oms_getReal(cref);

### Parameters
#### Path Parameters
- **cref** (any) - Required - Reference to the signal.

### Response
#### Success Response (status)
- **value** (real) - The real value of the signal.
- **status** (integer) - Indicates success or failure of the operation.
```

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

### Import Snapshot

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Loads a snapshot to restore a previous model state. The model must be in its virgin state (not instantiated).

```OpenModelica
status := oms_importSnapshot(cref, snapshot);

```

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

### Setting Optimization Initialization to FILE

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/optimization.html

Configure the system to use FILE initialization for optimization, loading the initial point from a specified .mat file.

```modelica
__OpenModelica_simulationFlags(ipopt_init="FILE" -iif "simModel_res.mat"),

```

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

### getAvailableLibraryVersions

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Returns the installed versions of a library.

```APIDOC
## getAvailableLibraryVersions

### Description
Returns the installed versions of a library.

### Function Signature
```
function getAvailableLibraryVersions
  input TypeName libraryName;
  output String[:] librariesAndVersions;
end getAvailableLibraryVersions;
```
```

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

### Experimental Real-time Simulation

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Starts an experimental soft real-time simulation for a given model identifier.

```c
oms_status_enu_t experimental_simulate_realtime(const char* ident);
```

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

### oms_setStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/scripting_api.html

Sets the start time of the simulation.

```APIDOC
## oms_setStartTime

### Description
Sets the start time of the simulation.

### Signature
```
function oms_setStartTime
  input String cref;
  input Real startTime;
  output Integer status;
end oms_setStartTime;
```
```

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

### Set Temporary Directory

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Sets a new temporary directory for the simulation. Requires the path to the new directory.

```c
oms_status_enu_t oms_setTempDirectory(const char* newTempDir);
```

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

### oms_setStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Sets the start time of the simulation.

```APIDOC
## oms_setStartTime

### Description
Set the start time of the simulation.

### Method
`oms_setStartTime(cref, startTime)`

### Parameters
- **cref** (object reference) - Required - Reference to the simulation object.
- **startTime** (double) - Required - The start time for the simulation.
```

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

### oms_getStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the start time from the model.

```APIDOC
## oms_getStartTime

### Description
Get the start time from the model.

### Method
```
startTime, status = oms_getStartTime(cref)
```
```

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

### Setting Optimization Initialization to SIM

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/optimization.html

Configure the system to use SIM initialization for optimization, where OpenModelica performs an initial simulation to set the starting point.

```modelica
__OpenModelica_simulationFlags(s = "optimization", optimizerNP = "1", ipopt_init= "SIM")

```

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

### oms_setStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Set the start time of the simulation.

```APIDOC
## oms_setStartTime

### Description
Set the start time of the simulation.

### Signature
```c
oms_status_enu_t oms_setStartTime(const char* cref, double startTime);
```
```

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

### Create New System Identification Model (Python)

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/systemidentification.html

Creates a new, empty model instance for parameter estimation in Python. Use the class constructor with a unique identifier string.

```python
simodel = OMSysIdent(ident)
```

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

### oms_getStartTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the start time from the model.

```APIDOC
## oms_getStartTime

### Description
Get the start time from the model.

### Function Signature
```c
oms_status_enu_t oms_getStartTime(const char* cref, double* startTime);
```
```

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

### Get Variable Step Size Parameters

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Retrieves the initial, minimum, and maximum step sizes for variable step solvers. Requires a model reference.

```OpenModelica
(initialStepSize, minimumStepSize, maximumStepSize, status) := oms_getVariableStepSize(cref);

```

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

### getStopTime

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Gets the stop time from the model.

```APIDOC
## getStopTime

### Description
Get the stop time from the model.

### Method Signature
```
stopTime, status = oms.getStopTime(cref)
```
```

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

### getReal

Source: https://openmodelica.org/doc/OpenModelicaUsersGuide/latest/omsimulator.html

Gets the real value of a signal.

```APIDOC
## getReal

### Description
Get real value.

### Method Signature
```
value, status = oms.getReal(cref)
```
```
Tokens:
Raw