Scripting API

The following are short summaries of OpenModelica scripting commands. These commands are useful for loading and saving classes, reading and storing data, plotting of results, and various other tasks.

The arguments passed to a scripting function should follow syntactic and typing rules for Modelica and for the scripting function in question. In the following tables we briefly indicate the types or character of the formal parameters to the functions by the following notation:

• String typed argument, e.g. "hello", "myfile.mo".

• TypeName - class, package or function name, e.g. MyClass,

  Modelica.Math.

• VariableName - variable name, e.g. v1, v2, vars1[2].x, etc.

• Integer or Real typed argument, e.g. 35, 3.14, xintvariable.

• options - optional parameters with named formal parameter passing.

OpenModelica Scripting Commands

The following are brief descriptions of the scripting commands available in the OpenModelica environment. See also https://build.openmodelica.org/Documentation/OpenModelica.Scripting.html. All commands are shown in alphabetical order:

interactiveDumpAbsynToJL

function interactiveDumpAbsynToJL
  output String res;
end interactiveDumpAbsynToJL;

relocateFunctions

function relocateFunctions
  input String fileName;
  input String names[:, 2];
  output Boolean success;
end relocateFunctions;

toJulia

function toJulia
  output String res;
end toJulia;

GC_expand_hp

function GC_expand_hp
  input Integer size;
  output Boolean success;
end GC_expand_hp;

GC_gcollect_and_unmap

GC_get_prof_stats

function GC_get_prof_stats
  output GC_PROFSTATS gcStats;
end GC_get_prof_stats;

GC_set_max_heap_size

function GC_set_max_heap_size
  input Integer size;
  output Boolean success;
end GC_set_max_heap_size;

addClassAnnotation

function addClassAnnotation
  input TypeName class_;
  input ExpressionOrModification annotate;
  output Boolean bool;
end addClassAnnotation;

addInitialState

function addInitialState
  input TypeName cl;
  input String state;
  input ExpressionOrModification annotate;
  output Boolean bool;
end addInitialState;

addTransition

function addTransition
  input TypeName cl;
  input String from;
  input String to;
  input String condition;
  input Boolean immediate = true;
  input Boolean reset = true;
  input Boolean synchronize = false;
  input Integer priority = 1;
  input ExpressionOrModification annotate;
  output Boolean bool;
end addTransition;

alarm

impure function alarm
  input Integer seconds;
  output Integer previousSeconds;
end alarm;

appendEnvironmentVar

Appends a variable to the environment variables list.

function appendEnvironmentVar
  input String var;
  input String value;
  output String result "returns \"error\" if the variable could not be appended";
end appendEnvironmentVar;

basename

function basename
  input String path;
  output String basename;
end basename;

buildEncryptedPackage

function buildEncryptedPackage
  input TypeName className "the class that should encrypted";
  input Boolean encrypt = true;
  output Boolean success;
end buildEncryptedPackage;

buildLabel

builds Label.

function buildLabel
  input TypeName className "the class that should be built";
  input Real startTime = 0.0 "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "dassl" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "" "fileNamePrefix. <default> = \"\"";
  input String options = "" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "" "cflags. <default> = \"\"";
  input String simflags = "" "simflags. <default> = \"\"";
  output String[2] buildModelResults;
end buildLabel;

buildModel

builds a modelica model by generating c code and build it.
It does not run the code!
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [tolerance], [method], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
buildModel(A);

function buildModel
  input TypeName className "the class that should be built";
  input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "<default>" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
  input String options = "<default>" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "<default>" "cflags. <default> = \"\"";
  input String simflags = "<default>" "simflags. <default> = \"\"";
  output String[2] buildModelResults;
end buildModel;

buildModelFMU

translates a modelica model into a Functional Mockup Unit.
The only required argument is the className, while all others have some default values.
Example command:
buildModelFMU(className, version="2.0");

function buildModelFMU
  input TypeName className "the class that should translated";
  input String version = "2.0" "FMU version, 1.0 or 2.0.";
  input String fmuType = "me" "FMU type, me (model exchange), cs (co-simulation), me_cs (both model exchange and co-simulation)";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"className\"";
  input String platforms[:] = {"static"} "The list of platforms to generate code for.
                                            \"dynamic\"=current platform, dynamically link the runtime.
                                            \"static\"=current platform, statically link everything.
                                            \"<cpu>-<vendor>-<os>\", host tripple, e.g. \"x86_64-linux-gnu\" or \"x86_64-w64-mingw32\".
                                            \"<cpu>-<vendor>-<os> docker run <image>\" host tripple with Docker image, e.g. \"x86_64-linux-gnu docker run --pull=never multiarch/crossbuild\"";
  input Boolean includeResources = false "Depreacted and no effect";
  output String generatedFileName "Returns the full path of the generated FMU.";
end buildModelFMU;

cd

change directory to the given path (which may be either relative or absolute)
returns the new working directory on success or a message on failure
if the given path is the empty string, the function simply returns the current working directory.

function cd
  input String newWorkingDirectory = "";
  output String workingDirectory;
end cd;

checkAllModelsRecursive

Checks all models recursively and returns number of variables and equations.

function checkAllModelsRecursive
  input TypeName className;
  input Boolean checkProtected = false "Checks also protected classes if true";
  output String result;
end checkAllModelsRecursive;

checkCodeGraph

Checks if the given taskgraph has the same structure as the graph described in the codefile.

function checkCodeGraph
  input String graphfile;
  input String codefile;
  output String[:] result;
end checkCodeGraph;

checkInterfaceOfPackages

function checkInterfaceOfPackages
  input TypeName cl;
  input String dependencyMatrix[:, :];
  output Boolean success;
end checkInterfaceOfPackages;

checkModel

Checks a model and returns number of variables and equations.

function checkModel
  input TypeName className;
  output String result;
end checkModel;

checkSettings

Display some diagnostics.

function checkSettings
  output CheckSettingsResult result;
end checkSettings;

checkTaskGraph

Checks if the given taskgraph has the same structure as the reference taskgraph and if all attributes are set correctly.

function checkTaskGraph
  input String filename;
  input String reffilename;
  output String[:] result;
end checkTaskGraph;

classAnnotationExists

Check if annotation exists

function classAnnotationExists
  input TypeName className;
  input TypeName annotationName;
  output Boolean exists;
end classAnnotationExists;

clear

Clears everything: symboltable and variables.

function clear
  output Boolean success;
end clear;

clearCommandLineOptions

Resets all command-line flags to their default values.

function clearCommandLineOptions
  output Boolean success;
end clearCommandLineOptions;

clearDebugFlags

Resets all debug flags to their default values.

function clearDebugFlags
  output Boolean success;
end clearDebugFlags;

clearMessages

Clears the error buffer.

function clearMessages
  output Boolean success;
end clearMessages;

clearProgram

Clears loaded .

function clearProgram
  output Boolean success;
end clearProgram;

clearVariables

Clear all user defined variables.

function clearVariables
  output Boolean success;
end clearVariables;

closeSimulationResultFile

Closes the current simulation result file.
Only needed by Windows. Windows cannot handle reading and writing to the same file from different processes.
To allow OMEdit to make successful simulation again on the same file we must close the file after reading the Simulation Result Variables.
Even OMEdit only use this API for Windows.

function closeSimulationResultFile
  output Boolean success;
end closeSimulationResultFile;

codeToString

function codeToString
  input $Code className;
  output String string;
end codeToString;

compareFiles

impure function compareFiles
  input String file1;
  input String file2;
  output Boolean isEqual;
end compareFiles;

compareFilesAndMove

impure function compareFilesAndMove
  input String newFile;
  input String oldFile;
  output Boolean success;
end compareFilesAndMove;

convertPackageToLibrary

function convertPackageToLibrary
  input TypeName packageToConvert;
  input TypeName library;
  input String libraryVersion;
  output Boolean success;
end convertPackageToLibrary;

convertUnits

function convertUnits
  input String s1;
  input String s2;
  output Boolean unitsCompatible;
  output Real scaleFactor;
  output Real offset;
end convertUnits;

copy

copies the source file to the destination file. Returns true if the file has been copied.

function copy
  input String source;
  input String destination;
  output Boolean success;
end copy;

copyClass

Copies a class within the same level

function copyClass
  input TypeName className "the class that should be copied";
  input String newClassName "the name for new class";
  input TypeName withIn = $Code(__OpenModelica_TopLevel) "the with in path for new class";
  output Boolean result;
end copyClass;

countMessages

function countMessages
  output Integer numMessages;
  output Integer numErrors;
  output Integer numWarnings;
end countMessages;

deleteFile

Deletes a file with the given name.

function deleteFile
  input String fileName;
  output Boolean success;
end deleteFile;

deleteInitialState

function deleteInitialState
  input TypeName cl;
  input String state;
  output Boolean bool;
end deleteInitialState;

deleteTransition

function deleteTransition
  input TypeName cl;
  input String from;
  input String to;
  input String condition;
  input Boolean immediate;
  input Boolean reset;
  input Boolean synchronize;
  input Integer priority;
  output Boolean bool;
end deleteTransition;

deltaSimulationResults

calculates the sum of absolute errors.

function deltaSimulationResults
  input String filename;
  input String reffilename;
  input String method "method to compute then error. choose 1norm, 2norm, maxerr";
  input String[:] vars = fill("", 0);
  output Real result;
end deltaSimulationResults;

diffModelicaFileListings

Creates diffs of two strings corresponding to Modelica files

function diffModelicaFileListings
  input String before, after;
  input DiffFormat diffFormat = DiffFormat.color;
  input Boolean failOnSemanticsChange = false "Defaults to returning after instead of hard fail";
  output String result;
end diffModelicaFileListings;

diffSimulationResults

compares simulation results.

function diffSimulationResults
  input String actualFile;
  input String expectedFile;
  input String diffPrefix;
  input Real relTol = 1e-3 "y tolerance";
  input Real relTolDiffMinMax = 1e-4 "y tolerance based on the difference between the maximum and minimum of the signal";
  input Real rangeDelta = 0.002 "x tolerance";
  input String[:] vars = fill("", 0);
  input Boolean keepEqualResults = false;
  output Boolean success;
  output String[:] failVars;
end diffSimulationResults;

diffSimulationResultsHtml

function diffSimulationResultsHtml
  input String var;
  input String actualFile;
  input String expectedFile;
  input Real relTol = 1e-3 "y tolerance";
  input Real relTolDiffMinMax = 1e-4 "y tolerance based on the difference between the maximum and minimum of the signal";
  input Real rangeDelta = 0.002 "x tolerance";
  output String html;
end diffSimulationResultsHtml;

directoryExists

function directoryExists
  input String dirName;
  output Boolean exists;
end directoryExists;

dirname

function dirname
  input String path;
  output String dirname;
end dirname;

disableNewInstantiation

function disableNewInstantiation
  output Boolean success;
end disableNewInstantiation;

dumpXMLDAE

Outputs the DAE system corresponding to a specific model.

function dumpXMLDAE
  input TypeName className;
  input String translationLevel = "flat" "flat, optimiser, backEnd, or stateSpace";
  input Boolean addOriginalAdjacencyMatrix = false;
  input Boolean addSolvingInfo = false;
  input Boolean addMathMLCode = false;
  input Boolean dumpResiduals = false;
  input String fileNamePrefix = "<default>" "this is the className in string form by default";
  input String rewriteRulesFile = "" "the file from where the rewiteRules are read, default is empty which means no rewrite rules";
  output Boolean success "if the function succeeded true/false";
  output String xmlfileName "the Xml file";
end dumpXMLDAE;

echo

echo(false) disables Interactive output, echo(true) enables it again.

function echo
  input Boolean setEcho;
  output Boolean newEcho;
end echo;

enableNewInstantiation

function enableNewInstantiation
  output Boolean success;
end enableNewInstantiation;

escapeXML

function escapeXML
  input String inStr;
  output String outStr;
end escapeXML;

exit

function exit
  input Integer status;
end exit;

exportToFigaro

function exportToFigaro
  input TypeName path;
  input String directory = cd();
  input String database;
  input String mode;
  input String options;
  input String processor;
  output Boolean success;
end exportToFigaro;

extendsFrom

returns true if the given class extends from the given base class

function extendsFrom
  input TypeName className;
  input TypeName baseClassName;
  output Boolean res;
end extendsFrom;

filterSimulationResults

function filterSimulationResults
  input String inFile;
  input String outFile;
  input String[:] vars;
  input Integer numberOfIntervals = 0 "0=Do not resample";
  input Boolean removeDescription = false;
  input Boolean hintReadAllVars = true;
  output Boolean success;
end filterSimulationResults;

generateCode

The input is a function name for which C-code is generated and compiled into a dll/so

function generateCode
  input TypeName className;
  output Boolean success;
end generateCode;

generateEntryPoint

function generateEntryPoint
  input String fileName;
  input TypeName entryPoint;
  input String url = "https://trac.openmodelica.org/OpenModelica/newticket";
end generateEntryPoint;

generateHeader

function generateHeader
  input String fileName;
  output Boolean success;
end generateHeader;

generateJuliaHeader

function generateJuliaHeader
  input String fileName;
  output Boolean success;
end generateJuliaHeader;

generateScriptingAPI

function generateScriptingAPI
  input TypeName cl;
  input String name;
  output Boolean success;
  output String moFile;
  output String qtFile;
  output String qtHeader;
end generateScriptingAPI;

generateSeparateCode

function generateSeparateCode
  input TypeName className;
  input Boolean cleanCache = false "If true, the cache is reset between each generated package. This conserves memory at the cost of speed.";
  output Boolean success;
end generateSeparateCode;

generateSeparateCodeDependencies

function generateSeparateCodeDependencies
  input String stampSuffix = ".c" "Suffix to add to dependencies (often .c.stamp)";
  output String[:] dependencies;
end generateSeparateCodeDependencies;

generateSeparateCodeDependenciesMakefile

function generateSeparateCodeDependenciesMakefile
  input String filename "The file to write the makefile to";
  input String directory = "" "The relative path of the generated files";
  input String suffix = ".c" "Often .stamp since we do not update all the files";
  output Boolean success;
end generateSeparateCodeDependenciesMakefile;

generateVerificationScenarios

function generateVerificationScenarios
  input TypeName path;
  output Boolean success;
end generateVerificationScenarios;

getAlgorithmCount

Counts the number of Algorithm sections in a class.

function getAlgorithmCount
  input TypeName class_;
  output Integer count;
end getAlgorithmCount;

getAlgorithmItemsCount

Counts the number of Algorithm items in a class.

function getAlgorithmItemsCount
  input TypeName class_;
  output Integer count;
end getAlgorithmItemsCount;

getAllSubtypeOf

Returns the list of all classes that extend from className given a parentClass where the lookup for className should start

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

getAnnotationCount

Counts the number of Annotation sections in a class.

function getAnnotationCount
  input TypeName class_;
  output Integer count;
end getAnnotationCount;

getAnnotationModifierValue

function getAnnotationModifierValue
  input TypeName name;
  input String vendorannotation;
  input String modifiername;
  output String modifiernamevalue;
end getAnnotationModifierValue;

getAnnotationNamedModifiers

function getAnnotationNamedModifiers
  input TypeName name;
  input String vendorannotation;
  output String[:] modifiernamelist;
end getAnnotationNamedModifiers;

getAnnotationVersion

Returns the current annotation version.

function getAnnotationVersion
  output String annotationVersion;
end getAnnotationVersion;

getAstAsCorbaString

Print the whole AST on the CORBA format for records, e.g.
record Absyn.PROGRAM
classes = ...,
within_ = ...,
globalBuildTimes = ...
end Absyn.PROGRAM;

function getAstAsCorbaString
  input String fileName = "<interactive>";
  output String result "returns the string if fileName is interactive; else it returns ok or error depending on if writing the file succeeded";
end getAstAsCorbaString;

getAvailableIndexReductionMethods

function getAvailableIndexReductionMethods
  output String[:] allChoices;
  output String[:] allComments;
end getAvailableIndexReductionMethods;

getAvailableLibraries

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

getAvailableLibraryVersions

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

getAvailableMatchingAlgorithms

function getAvailableMatchingAlgorithms
  output String[:] allChoices;
  output String[:] allComments;
end getAvailableMatchingAlgorithms;

getAvailablePackageConversionsFrom

function getAvailablePackageConversionsFrom
  input TypeName pkg;
  input String version;
  output String[:] convertsTo;
end getAvailablePackageConversionsFrom;

getAvailablePackageConversionsTo

function getAvailablePackageConversionsTo
  input TypeName pkg;
  input String version;
  output String[:] convertsTo;
end getAvailablePackageConversionsTo;

getAvailablePackageVersions

function getAvailablePackageVersions
  input TypeName pkg;
  input String version;
  output String[:] withoutConversion;
end getAvailablePackageVersions;

getAvailableTearingMethods

function getAvailableTearingMethods
  output String[:] allChoices;
  output String[:] allComments;
end getAvailableTearingMethods;

getBooleanClassAnnotation

Check if annotation exists and returns its value

function getBooleanClassAnnotation
  input TypeName className;
  input TypeName annotationName;
  output Boolean value;
end getBooleanClassAnnotation;

getBuiltinType

function getBuiltinType
  input TypeName cl;
  output String name;
end getBuiltinType;

getCFlags

CFLAGS

function getCFlags
  output String outString;
end getCFlags;

getCXXCompiler

CXX

function getCXXCompiler
  output String compiler;
end getCXXCompiler;

getClassComment

Returns the class comment.

function getClassComment
  input TypeName cl;
  output String comment;
end getClassComment;

getClassInformation

function getClassInformation
  input TypeName cl;
  output String restriction, comment;
  output Boolean partialPrefix, finalPrefix, encapsulatedPrefix;
  output String fileName;
  output Boolean fileReadOnly;
  output Integer lineNumberStart, columnNumberStart, lineNumberEnd, columnNumberEnd;
  output String dimensions[:];
  output Boolean isProtectedClass;
  output Boolean isDocumentationClass;
  output String version;
  output String preferredView;
  output Boolean state;
  output String access;
  output String versionDate;
  output String versionBuild;
  output String dateModified;
  output String revisionId;
end getClassInformation;

getClassNames

Returns the list of class names defined in the class.

function getClassNames
  input TypeName class_ = $Code(AllLoadedClasses);
  input Boolean recursive = false;
  input Boolean qualified = false;
  input Boolean sort = false;
  input Boolean builtin = false "List also builtin classes if true";
  input Boolean showProtected = false "List also protected classes if true";
  input Boolean includeConstants = false "List also constants in the class if true";
  output TypeName classNames[:];
end getClassNames;

getClassRestriction

function getClassRestriction
  input TypeName cl;
  output String restriction;
end getClassRestriction;

getClassesInModelicaPath

MathCore-specific or not? Who knows!

function getClassesInModelicaPath
  output String classesInModelicaPath;
end getClassesInModelicaPath;

getCommandLineOptions

Returns all command line options who have non-default values as a list of
strings. The format of the strings is '--flag=value --flag2=value2'.

function getCommandLineOptions
  output String[:] flags;
end getCommandLineOptions;

getCompileCommand

function getCompileCommand
  output String compileCommand;
end getCompileCommand;

getCompiler

CC

function getCompiler
  output String compiler;
end getCompiler;

getComponentModifierNames

function getComponentModifierNames
  input TypeName class_;
  input String componentName;
  output String[:] modifiers;
end getComponentModifierNames;

getComponentModifierValue

function getComponentModifierValue
  input TypeName class_;
  input TypeName modifier;
  output String value;
end getComponentModifierValue;

getComponentModifierValues

function getComponentModifierValues
  input TypeName class_;
  input TypeName modifier;
  output String value;
end getComponentModifierValues;

getComponentsTest

returns an array of records with information about the components of the given class

function getComponentsTest
  input TypeName name;
  output Component[:] components;
  record Component
    String className "the type of the component";
    String name "the name of the component";
    String comment "the comment of the component";
    Boolean isProtected "true if component is protected";
    Boolean isFinal "true if component is final";
    Boolean isFlow "true if component is flow";
    Boolean isStream "true if component is stream";
    Boolean isReplaceable "true if component is replaceable";
    String variability "'constant', 'parameter', 'discrete', ''";
    String innerOuter "'inner', 'outer', ''";
    String inputOutput "'input', 'output', ''";
    String dimensions[:] "array with the dimensions of the component";
  end Component;
end getComponentsTest;

getConfigFlagValidOptions

Returns the list of valid options for a string config flag, and the description strings for these options if available

function getConfigFlagValidOptions
  input String flag;
  output String validOptions[:];
  output String mainDescription;
  output String descriptions[:];
end getConfigFlagValidOptions;

getConnectionCount

Counts the number of connect equation in a class.

function getConnectionCount
  input TypeName className;
  output Integer count;
end getConnectionCount;

getConnectionList

returns an array of all connections including those within loops

function getConnectionList
  input TypeName className;
  output String[:, :] result;
end getConnectionList;

getConversionsFromVersions

function getConversionsFromVersions
  input TypeName pack;
  output String[:] withoutConversion;
  output String[:] withConversion;
end getConversionsFromVersions;

getDefaultOpenCLDevice

Returns the id for the default OpenCL device to be used.

function getDefaultOpenCLDevice
  output Integer defdevid;
end getDefaultOpenCLDevice;

getDerivedClassModifierNames

Returns the derived class modifier names.
Example command:
type Resistance = Real(final quantity="Resistance",final unit="Ohm");
getDerivedClassModifierNames(Resistance) => {"quantity","unit"}

function getDerivedClassModifierNames
  input TypeName className;
  output String[:] modifierNames;
end getDerivedClassModifierNames;

getDerivedClassModifierValue

Returns the derived class modifier value.
Example command:
type Resistance = Real(final quantity="Resistance",final unit="Ohm");
getDerivedClassModifierValue(Resistance, unit); => " = "Ohm""
getDerivedClassModifierValue(Resistance, quantity); => " = "Resistance""

function getDerivedClassModifierValue
  input TypeName className;
  input TypeName modifierName;
  output String modifierValue;
end getDerivedClassModifierValue;

getDerivedUnits

function getDerivedUnits
  input String baseUnit;
  output String[:] derivedUnits;
end getDerivedUnits;

getDocumentationAnnotation

Returns the documentaiton annotation defined in the class.

function getDocumentationAnnotation
  input TypeName cl;
  output String out[3] "{info,revision,infoHeader} TODO: Should be changed to have 2 outputs instead of an array of 2 Strings...";
end getDocumentationAnnotation;

getElementAnnotation

function getElementAnnotation
  input TypeName elementName;
  output String annotationString;
end getElementAnnotation;

getElementModifierNames

function getElementModifierNames
  input TypeName className;
  input String elementName;
  output String[:] modifiers;
end getElementModifierNames;

getElementModifierValue

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

getElementModifierValues

function getElementModifierValues
  input TypeName className;
  input TypeName modifier;
  output String value;
end getElementModifierValues;

getEnvironmentVar

Returns the value of the environment variable.

function getEnvironmentVar
  input String var;
  output String value "returns empty string on failure";
end getEnvironmentVar;

getEquationCount

Counts the number of Equation sections in a class.

function getEquationCount
  input TypeName class_;
  output Integer count;
end getEquationCount;

getEquationItemsCount

Counts the number of Equation items in a class.

function getEquationItemsCount
  input TypeName class_;
  output Integer count;
end getEquationItemsCount;

getErrorString

Returns the current error message. [file.mo:n:n-n:n:b] Error: message

impure function getErrorString
  input Boolean warningsAsErrors = false;
  output String errorString;
end getErrorString;

getHomeDirectoryPath

This returns the path to user HOME directory.

function getHomeDirectoryPath
  output String homeDirectoryPath;
end getHomeDirectoryPath;

getImportCount

Counts the number of Import sections in a class.

function getImportCount
  input TypeName class_;
  output Integer count;
end getImportCount;

getImportedNames

Returns the prefix paths of all imports in a class.

function getImportedNames
  input TypeName class_;
  output String[:] out_public;
  output String[:] out_protected;
end getImportedNames;

getIndexReductionMethod

function getIndexReductionMethod
  output String selected;
end getIndexReductionMethod;

getInheritedClasses

function getInheritedClasses
  input TypeName name;
  output TypeName inheritedClasses[:];
end getInheritedClasses;

getInitialAlgorithmCount

Counts the number of Initial Algorithm sections in a class.

function getInitialAlgorithmCount
  input TypeName class_;
  output Integer count;
end getInitialAlgorithmCount;

getInitialAlgorithmItemsCount

Counts the number of Initial Algorithm items in a class.

function getInitialAlgorithmItemsCount
  input TypeName class_;
  output Integer count;
end getInitialAlgorithmItemsCount;

getInitialEquationCount

Counts the number of Initial Equation sections in a class.

function getInitialEquationCount
  input TypeName class_;
  output Integer count;
end getInitialEquationCount;

getInitialEquationItemsCount

Counts the number of Initial Equation items in a class.

function getInitialEquationItemsCount
  input TypeName class_;
  output Integer count;
end getInitialEquationItemsCount;

getInitialStates

function getInitialStates
  input TypeName cl;
  output String[:, :] initialStates;
end getInitialStates;

getInstallationDirectoryPath

This returns OPENMODELICAHOME if it is set; on some platforms the default path is returned if it is not set.

function getInstallationDirectoryPath
  output String installationDirectoryPath;
end getInstallationDirectoryPath;

getInstantiatedParametersAndValues

function getInstantiatedParametersAndValues
  input TypeName cls;
  output String[:] values;
end getInstantiatedParametersAndValues;

getLanguageStandard

Returns the current Modelica Language Standard in use.

function getLanguageStandard
  output String outVersion;
end getLanguageStandard;

getLinker

function getLinker
  output String linker;
end getLinker;

getLinkerFlags

function getLinkerFlags
  output String linkerFlags;
end getLinkerFlags;

getLoadedLibraries

function getLoadedLibraries
  output String[:, 2] libraries;
end getLoadedLibraries;

getMMfileTotalDependencies

function getMMfileTotalDependencies
  input String in_package_name;
  input String public_imports_dir;
  output String[:] total_pub_imports;
end getMMfileTotalDependencies;

getMatchingAlgorithm

function getMatchingAlgorithm
  output String selected;
end getMatchingAlgorithm;

getMemorySize

function getMemorySize
  output Real memory(unit = "MiB");
end getMemorySize;

getMessagesString

see getErrorString()

function getMessagesString
  output String messagesString;
end getMessagesString;

getModelInstance

Dumps a model instance as a JSON string.

function getModelInstance
  input TypeName className;
  input String modifier = "";
  input Boolean prettyPrint = false;
  output String result;
end getModelInstance;

getModelInstanceAnnotation

Dumps the annotation of a model using the same JSON format as
getModelInstance, optionally filtering out only certain parts.

function getModelInstanceAnnotation
  input TypeName className;
  input String[:] filter = fill("", 0);
  input Boolean prettyPrint = false;
  output String result;
end getModelInstanceAnnotation;

getModelicaPath

Get the Modelica Library Path.

function getModelicaPath
  output String modelicaPath;
end getModelicaPath;

getNoSimplify

Returns true if noSimplify flag is set.

function getNoSimplify
  output Boolean noSimplify;
end getNoSimplify;

getNthAlgorithm

Returns the Nth Algorithm section.

function getNthAlgorithm
  input TypeName class_;
  input Integer index;
  output String result;
end getNthAlgorithm;

getNthAlgorithmItem

Returns the Nth Algorithm Item.

function getNthAlgorithmItem
  input TypeName class_;
  input Integer index;
  output String result;
end getNthAlgorithmItem;

getNthAnnotationString

Returns the Nth Annotation section as string.

function getNthAnnotationString
  input TypeName class_;
  input Integer index;
  output String result;
end getNthAnnotationString;

getNthConnection

Returns the Nth connection.
Example command:
getNthConnection(A) => {"from", "to", "comment"}

function getNthConnection
  input TypeName className;
  input Integer index;
  output String[:] result;
end getNthConnection;

getNthEquation

Returns the Nth Equation section.

function getNthEquation
  input TypeName class_;
  input Integer index;
  output String result;
end getNthEquation;

getNthEquationItem

Returns the Nth Equation Item.

function getNthEquationItem
  input TypeName class_;
  input Integer index;
  output String result;
end getNthEquationItem;

getNthImport

Returns the Nth Import as string.

function getNthImport
  input TypeName class_;
  input Integer index;
  output String out[3] "{\"Path\",\"Id\",\"Kind\"}";
end getNthImport;

getNthInitialAlgorithm

Returns the Nth Initial Algorithm section.

function getNthInitialAlgorithm
  input TypeName class_;
  input Integer index;
  output String result;
end getNthInitialAlgorithm;

getNthInitialAlgorithmItem

Returns the Nth Initial Algorithm Item.

function getNthInitialAlgorithmItem
  input TypeName class_;
  input Integer index;
  output String result;
end getNthInitialAlgorithmItem;

getNthInitialEquation

Returns the Nth Initial Equation section.

function getNthInitialEquation
  input TypeName class_;
  input Integer index;
  output String result;
end getNthInitialEquation;

getNthInitialEquationItem

Returns the Nth Initial Equation Item.

function getNthInitialEquationItem
  input TypeName class_;
  input Integer index;
  output String result;
end getNthInitialEquationItem;

getOrderConnections

Returns true if orderConnections flag is set.

function getOrderConnections
  output Boolean orderConnections;
end getOrderConnections;

getPackages

Returns the list of packages defined in the class.

function getPackages
  input TypeName class_ = $Code(AllLoadedClasses);
  output TypeName classNames[:];
end getPackages;

getParameterNames

function getParameterNames
  input TypeName class_;
  output String[:] parameters;
end getParameterNames;

getParameterValue

function getParameterValue
  input TypeName class_;
  input String parameterName;
  output String parameterValue;
end getParameterValue;

getSettings

function getSettings
  output String settings;
end getSettings;

getShowAnnotations

function getShowAnnotations
  output Boolean show;
end getShowAnnotations;

getSimulationOptions

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;

getSourceFile

Returns the filename of the class.

function getSourceFile
  input TypeName class_;
  output String filename "empty on failure";
end getSourceFile;

getTearingMethod

function getTearingMethod
  output String selected;
end getTearingMethod;

getTempDirectoryPath

Returns the current user temporary directory location.

function getTempDirectoryPath
  output String tempDirectoryPath;
end getTempDirectoryPath;

getTimeStamp

function getTimeStamp
  input TypeName cl;
  output Real timeStamp;
  output String timeStampAsString;
end getTimeStamp;

getTransitions

function getTransitions
  input TypeName cl;
  output String[:, :] transitions;
end getTransitions;

getUsedClassNames

Returns the list of class names used in the total program defined by the class.

function getUsedClassNames
  input TypeName className;
  output TypeName classNames[:];
end getUsedClassNames;

getUses

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

getVectorizationLimit

function getVectorizationLimit
  output Integer vectorizationLimit;
end getVectorizationLimit;

getVersion

Returns the version of the Modelica compiler.

function getVersion
  input TypeName cl = $Code(OpenModelica);
  output String version;
end getVersion;

help

display the OpenModelica help text.

function help
  input String topic = "topics";
  output String helpText;
end help;

iconv

The iconv() function converts one multibyte characters from one character
set to another.
See man (3) iconv for more information.

function iconv
  input String string;
  input String from;
  input String to = "UTF-8";
  output String result;
end iconv;

importFMU

Imports the Functional Mockup Unit
Example command:
importFMU("A.fmu");

function importFMU
  input String filename "the fmu file name";
  input String workdir = "<default>" "The output directory for imported FMU files. <default> will put the files to current working directory.";
  input Integer loglevel = 3 "loglevel_nothing=0;loglevel_fatal=1;loglevel_error=2;loglevel_warning=3;loglevel_info=4;loglevel_verbose=5;loglevel_debug=6";
  input Boolean fullPath = false "When true the full output path is returned otherwise only the file name.";
  input Boolean debugLogging = false "When true the FMU's debug output is printed.";
  input Boolean generateInputConnectors = true "When true creates the input connector pins.";
  input Boolean generateOutputConnectors = true "When true creates the output connector pins.";
  input TypeName modelName = $Code(Default) "Name of the generated model. If default then the name is auto generated using FMU information.";
  output String generatedFileName "Returns the full path of the generated file.";
end importFMU;

importFMUModelDescription

Imports modelDescription.xml
Example command:
importFMUModelDescription("A.xml");

function importFMUModelDescription
  input String filename "the fmu file name";
  input String workdir = "<default>" "The output directory for imported FMU files. <default> will put the files to current working directory.";
  input Integer loglevel = 3 "loglevel_nothing=0;loglevel_fatal=1;loglevel_error=2;loglevel_warning=3;loglevel_info=4;loglevel_verbose=5;loglevel_debug=6";
  input Boolean fullPath = false "When true the full output path is returned otherwise only the file name.";
  input Boolean debugLogging = false "When true the FMU's debug output is printed.";
  input Boolean generateInputConnectors = true "When true creates the input connector pins.";
  input Boolean generateOutputConnectors = true "When true creates the output connector pins.";
  output String generatedFileName "Returns the full path of the generated file.";
end importFMUModelDescription;

inferBindings

function inferBindings
  input TypeName path;
  output Boolean success;
end inferBindings;

installPackage

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

instantiateModel

Instantiates the class and returns the flat Modelica code.

function instantiateModel
  input TypeName className;
  output String result;
end instantiateModel;

isBlock

function isBlock
  input TypeName cl;
  output Boolean b;
end isBlock;

isClass

function isClass
  input TypeName cl;
  output Boolean b;
end isClass;

isConnector

function isConnector
  input TypeName cl;
  output Boolean b;
end isConnector;

isEnumeration

function isEnumeration
  input TypeName cl;
  output Boolean b;
end isEnumeration;

isExperiment

function isExperiment
  input TypeName name;
  output Boolean res;
end isExperiment;

isFunction

function isFunction
  input TypeName cl;
  output Boolean b;
end isFunction;

isModel

function isModel
  input TypeName cl;
  output Boolean b;
end isModel;

isOperator

function isOperator
  input TypeName cl;
  output Boolean b;
end isOperator;

isOperatorFunction

function isOperatorFunction
  input TypeName cl;
  output Boolean b;
end isOperatorFunction;

isOperatorRecord

function isOperatorRecord
  input TypeName cl;
  output Boolean b;
end isOperatorRecord;

isOptimization

function isOptimization
  input TypeName cl;
  output Boolean b;
end isOptimization;

isPackage

function isPackage
  input TypeName cl;
  output Boolean b;
end isPackage;

isPartial

function isPartial
  input TypeName cl;
  output Boolean b;
end isPartial;

isProtectedClass

function isProtectedClass
  input TypeName cl;
  input String c2;
  output Boolean b;
end isProtectedClass;

isRecord

function isRecord
  input TypeName cl;
  output Boolean b;
end isRecord;

isRedeclare

function isRedeclare
  input TypeName element;
  output Boolean b;
end isRedeclare;

isReplaceable

function isReplaceable
  input TypeName element;
  output Boolean b;
end isReplaceable;

isShortDefinition

returns true if the definition is a short class definition

function isShortDefinition
  input TypeName class_;
  output Boolean isShortCls;
end isShortDefinition;

isType

function isType
  input TypeName cl;
  output Boolean b;
end isType;

linearize

creates a model with symbolic linearization matrices

function linearize
  input TypeName className "the class that should simulated";
  input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real stepSize = 0.002 "step size that is used for the result file. <default> = 0.002";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "<default>" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
  input Boolean storeInTemp = false "storeInTemp. <default> = false";
  input Boolean noClean = false "noClean. <default> = false";
  input String options = "<default>" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "<default>" "cflags. <default> = \"\"";
  input String simflags = "<default>" "simflags. <default> = \"\"";
  output String linearizationResult;
end linearize;

list

Lists the contents of the given class, or all loaded classes.

function list
  input TypeName class_ = $Code(AllLoadedClasses);
  input Boolean interfaceOnly = false;
  input Boolean shortOnly = false "only short class definitions";
  input ExportKind exportKind = ExportKind.Absyn;
  output String contents;
end list;

listFile

Lists the contents of the file given by the class.

function listFile
  input TypeName class_;
  input Boolean nestedClasses = true;
  output String contents;
end listFile;

listVariables

Lists the names of the active variables in the scripting environment.

function listVariables
  output TypeName variables[:];
end listVariables;

loadClassContentString

Loads class elements from a string and inserts them into the given loaded class.

function loadClassContentString
  input String data;
  input TypeName className;
  output Boolean success;
end loadClassContentString;

loadEncryptedPackage

function loadEncryptedPackage
  input String fileName;
  input String workdir = "<default>" "The output directory for imported encrypted files. <default> will put the files to current working directory.";
  input Boolean skipUnzip = false "Skips the unzip of .mol if true. In that case we expect the files are already extracted e.g., because of parseEncryptedPackage() call.";
  input Boolean uses = true;
  input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output Boolean success;
end loadEncryptedPackage;

loadFile

load file (*.mo) and merge it with the loaded AST.

function loadFile
  input String fileName;
  input String encoding = "UTF-8";
  input Boolean uses = true;
  input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output Boolean success;
end loadFile;

loadFileInteractive

function loadFileInteractive
  input String filename;
  input String encoding = "UTF-8";
  input Boolean uses = true;
  input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output TypeName names[:];
end loadFileInteractive;

loadFileInteractiveQualified

function loadFileInteractiveQualified
  input String filename;
  input String encoding = "UTF-8";
  output TypeName names[:];
end loadFileInteractiveQualified;

loadFiles

load files (*.mo) and merges them with the loaded AST.

function loadFiles
  input String[:] fileNames;
  input String encoding = "UTF-8";
  input Integer numThreads = OpenModelica.Scripting.numProcessors();
  input Boolean uses = true;
  input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output Boolean success;
end loadFiles;

loadModel

Loads the Modelica Standard Library.

function loadModel
  input TypeName className;
  input String[:] priorityVersion = {"default"};
  input Boolean notify = false "Give a notification of the libraries and versions that were loaded";
  input String languageStandard = "" "Override the set language standard. Parse with the given setting, but do not change it permanently.";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output Boolean success;
end loadModel;

loadModelica3D

function loadModelica3D
  input String version = "3.2.1";
  output Boolean status;
end loadModelica3D;

loadOMSimulator

loads the OMSimulator DLL from default path

function loadOMSimulator
  output Integer status;
end loadOMSimulator;

loadString

Parses the data and merges the resulting AST with ithe
loaded AST.
If a filename is given, it is used to provide error-messages as if the string
was read in binary format from a file with the same name.
The file is converted to UTF-8 from the given character set.
When merge is true the classes cNew in the file will be merged with the already loaded classes cOld in the following way:
1. get all the inner class definitions from cOld that were loaded from a different file than itself
2. append all elements from step 1 to class cNew public list
NOTE: Encoding is deprecated as *ALL* strings are now UTF-8 encoded.

function loadString
  input String data;
  input String filename = "<interactive>";
  input String encoding = "UTF-8" "Deprecated as *ALL* strings are now UTF-8 encoded";
  input Boolean merge = false "if merge is true the parsed AST is merged with the existing AST, default to false which means that is replaced, not merged";
  input Boolean uses = true;
  input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
  input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
  output Boolean success;
end loadString;

mkdir

create directory of given path (which may be either relative or absolute)
returns true if directory was created or already exists.

function mkdir
  input String newDirectory;
  output Boolean success;
end mkdir;

modifierToJSON

Parses a modifier given as a string and dumps it as JSON.

function modifierToJSON
  input String modifier;
  input Boolean prettyPrint = false;
  output String json;
end modifierToJSON;

moveClass

Moves a class up or down depending on the given offset, where a positive
offset moves the class down and a negative offset up. The offset is truncated
if the resulting index is outside the class list. It retains the visibility of
the class by adding public/protected sections when needed, and merges sections
of the same type if the class is moved from a section it was alone in. Returns
true if the move was successful, otherwise false.

function moveClass
  input TypeName className "the class that should be moved";
  input Integer offset "Offset in the class list.";
  output Boolean result;
end moveClass;

moveClassToBottom

Moves a class to the bottom of its enclosing class. Returns true if the move
was successful, otherwise false.

function moveClassToBottom
  input TypeName className;
  output Boolean result;
end moveClassToBottom;

moveClassToTop

Moves a class to the top of its enclosing class. Returns true if the move
was successful, otherwise false.

function moveClassToTop
  input TypeName className;
  output Boolean result;
end moveClassToTop;

ngspicetoModelica

Converts ngspice netlist to Modelica code. Modelica file is created in the same directory as netlist file.

function ngspicetoModelica
  input String netlistfileName;
  output Boolean success = false;
end ngspicetoModelica;

numProcessors

function numProcessors
  output Integer result;
end numProcessors;

oms_RunFile

function oms_RunFile
  input String filename;
  output Integer status;
end oms_RunFile;

oms_addBus

function oms_addBus
  input String cref;
  output Integer status;
end oms_addBus;

oms_addConnection

function oms_addConnection
  input String crefA;
  input String crefB;
  output Integer status;
end oms_addConnection;

oms_addConnector

function oms_addConnector
  input String cref;
  input oms_causality causality;
  input oms_signal_type type_;
  output Integer status;
end oms_addConnector;

oms_addConnectorToBus

function oms_addConnectorToBus
  input String busCref;
  input String connectorCref;
  output Integer status;
end oms_addConnectorToBus;

oms_addConnectorToTLMBus

function oms_addConnectorToTLMBus
  input String busCref;
  input String connectorCref;
  input String type_;
  output Integer status;
end oms_addConnectorToTLMBus;

oms_addDynamicValueIndicator

function oms_addDynamicValueIndicator
  input String signal;
  input String lower;
  input String upper;
  input Real stepSize;
  output Integer status;
end oms_addDynamicValueIndicator;

oms_addEventIndicator

function oms_addEventIndicator
  input String signal;
  output Integer status;
end oms_addEventIndicator;

oms_addExternalModel

function oms_addExternalModel
  input String cref;
  input String path;
  input String startscript;
  output Integer status;
end oms_addExternalModel;

oms_addSignalsToResults

function oms_addSignalsToResults
  input String cref;
  input String regex;
  output Integer status;
end oms_addSignalsToResults;

oms_addStaticValueIndicator

function oms_addStaticValueIndicator
  input String signal;
  input Real lower;
  input Real upper;
  input Real stepSize;
  output Integer status;
end oms_addStaticValueIndicator;

oms_addSubModel

function oms_addSubModel
  input String cref;
  input String fmuPath;
  output Integer status;
end oms_addSubModel;

oms_addSystem

function oms_addSystem
  input String cref;
  input oms_system type_;
  output Integer status;
end oms_addSystem;

oms_addTLMBus

function oms_addTLMBus
  input String cref;
  input oms_tlm_domain domain;
  input Integer dimensions;
  input oms_tlm_interpolation interpolation;
  output Integer status;
end oms_addTLMBus;

oms_addTLMConnection

function oms_addTLMConnection
  input String crefA;
  input String crefB;
  input Real delay;
  input Real alpha;
  input Real linearimpedance;
  input Real angularimpedance;
  output Integer status;
end oms_addTLMConnection;

oms_addTimeIndicator

function oms_addTimeIndicator
  input String signal;
  output Integer status;
end oms_addTimeIndicator;

oms_compareSimulationResults

function oms_compareSimulationResults
  input String filenameA;
  input String filenameB;
  input String var;
  input Real relTol;
  input Real absTol;
  output Integer status;
end oms_compareSimulationResults;

oms_copySystem

function oms_copySystem
  input String source;
  input String target;
  output Integer status;
end oms_copySystem;

oms_delete

function oms_delete
  input String cref;
  output Integer status;
end oms_delete;

oms_deleteConnection

function oms_deleteConnection
  input String crefA;
  input String crefB;
  output Integer status;
end oms_deleteConnection;

oms_deleteConnectorFromBus

function oms_deleteConnectorFromBus
  input String busCref;
  input String connectorCref;
  output Integer status;
end oms_deleteConnectorFromBus;

oms_deleteConnectorFromTLMBus

function oms_deleteConnectorFromTLMBus
  input String busCref;
  input String connectorCref;
  output Integer status;
end oms_deleteConnectorFromTLMBus;

oms_export

function oms_export
  input String cref;
  input String filename;
  output Integer status;
end oms_export;

oms_exportDependencyGraphs

function oms_exportDependencyGraphs
  input String cref;
  input String initialization;
  input String event;
  input String simulation;
  output Integer status;
end oms_exportDependencyGraphs;

oms_exportSnapshot

function oms_exportSnapshot
  input String cref;
  output String contents;
  output Integer status;
end oms_exportSnapshot;

oms_extractFMIKind

function oms_extractFMIKind
  input String filename;
  output Integer kind;
  output Integer status;
end oms_extractFMIKind;

oms_faultInjection

function oms_faultInjection
  input String signal;
  input oms_fault_type faultType;
  input Real faultValue;
  output Integer status;
end oms_faultInjection;

oms_getBoolean

function oms_getBoolean
  input String cref;
  output Boolean value;
  output Integer status;
end oms_getBoolean;

oms_getFixedStepSize

function oms_getFixedStepSize
  input String cref;
  output Real stepSize;
  output Integer status;
end oms_getFixedStepSize;

oms_getInteger

function oms_getInteger
  input String cref;
  input Integer value;
  output Integer status;
end oms_getInteger;

oms_getModelState

function oms_getModelState
  input String cref;
  output Integer modelState;
  output Integer status;
end oms_getModelState;

oms_getReal

function oms_getReal
  input String cref;
  output Real value;
  output Integer status;
end oms_getReal;

oms_getSolver

function oms_getSolver
  input String cref;
  output Integer solver;
  output Integer status;
end oms_getSolver;

oms_getStartTime

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

oms_getStopTime

function oms_getStopTime
  input String cref;
  output Real stopTime;
  output Integer status;
end oms_getStopTime;

oms_getSubModelPath

function oms_getSubModelPath
  input String cref;
  output String path;
  output Integer status;
end oms_getSubModelPath;

oms_getSystemType

function oms_getSystemType
  input String cref;
  output Integer type_;
  output Integer status;
end oms_getSystemType;

oms_getTolerance

function oms_getTolerance
  input String cref;
  output Real absoluteTolerance;
  output Real relativeTolerance;
  output Integer status;
end oms_getTolerance;

oms_getVariableStepSize

function oms_getVariableStepSize
  input String cref;
  output Real initialStepSize;
  output Real minimumStepSize;
  output Real maximumStepSize;
  output Integer status;
end oms_getVariableStepSize;

oms_getVersion

Returns the version of the OMSimulator.

function oms_getVersion
  output String version;
end oms_getVersion;

oms_importFile

function oms_importFile
  input String filename;
  output String cref;
  output Integer status;
end oms_importFile;

oms_importSnapshot

function oms_importSnapshot
  input String cref;
  input String snapshot;
  output Integer status;
end oms_importSnapshot;

oms_initialize

function oms_initialize
  input String cref;
  output Integer status;
end oms_initialize;

oms_instantiate

function oms_instantiate
  input String cref;
  output Integer status;
end oms_instantiate;

oms_list

function oms_list
  input String cref;
  output String contents;
  output Integer status;
end oms_list;

oms_listUnconnectedConnectors

function oms_listUnconnectedConnectors
  input String cref;
  output String contents;
  output Integer status;
end oms_listUnconnectedConnectors;

oms_loadSnapshot

function oms_loadSnapshot
  input String cref;
  input String snapshot;
  output String newCref;
  output Integer status;
end oms_loadSnapshot;

oms_newModel

function oms_newModel
  input String cref;
  output Integer status;
end oms_newModel;

oms_removeSignalsFromResults

function oms_removeSignalsFromResults
  input String cref;
  input String regex;
  output Integer status;
end oms_removeSignalsFromResults;

oms_rename

function oms_rename
  input String cref;
  input String newCref;
  output Integer status;
end oms_rename;

oms_reset

function oms_reset
  input String cref;
  output Integer status;
end oms_reset;

oms_setBoolean

function oms_setBoolean
  input String cref;
  input Boolean value;
  output Integer status;
end oms_setBoolean;

oms_setCommandLineOption

function oms_setCommandLineOption
  input String cmd;
  output Integer status;
end oms_setCommandLineOption;

oms_setFixedStepSize

function oms_setFixedStepSize
  input String cref;
  input Real stepSize;
  output Integer status;
end oms_setFixedStepSize;

oms_setInteger

function oms_setInteger
  input String cref;
  input Integer value;
  output Integer status;
end oms_setInteger;

oms_setLogFile

function oms_setLogFile
  input String filename;
  output Integer status;
end oms_setLogFile;

oms_setLoggingInterval

function oms_setLoggingInterval
  input String cref;
  input Real loggingInterval;
  output Integer status;
end oms_setLoggingInterval;

oms_setLoggingLevel

function oms_setLoggingLevel
  input Integer logLevel;
  output Integer status;
end oms_setLoggingLevel;

oms_setReal

function oms_setReal
  input String cref;
  input Real value;
  output Integer status;
end oms_setReal;

oms_setRealInputDerivative

function oms_setRealInputDerivative
  input String cref;
  input Real value;
  output Integer status;
end oms_setRealInputDerivative;

oms_setResultFile

function oms_setResultFile
  input String cref;
  input String filename;
  input Integer bufferSize;
  output Integer status;
end oms_setResultFile;

oms_setSignalFilter

function oms_setSignalFilter
  input String cref;
  input String regex;
  output Integer status;
end oms_setSignalFilter;

oms_setSolver

function oms_setSolver
  input String cref;
  input oms_solver solver;
  output Integer status;
end oms_setSolver;

oms_setStartTime

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

oms_setStopTime

function oms_setStopTime
  input String cref;
  input Real stopTime;
  output Integer status;
end oms_setStopTime;

oms_setTLMPositionAndOrientation

function oms_setTLMPositionAndOrientation
  input String cref;
  input Real x1;
  input Real x2;
  input Real x3;
  input Real A11;
  input Real A12;
  input Real A13;
  input Real A21;
  input Real A22;
  input Real A23;
  input Real A31;
  input Real A32;
  input Real A33;
  output Integer status;
end oms_setTLMPositionAndOrientation;

oms_setTLMSocketData

function oms_setTLMSocketData
  input String cref;
  input String address;
  input Integer managerPort;
  input Integer monitorPort;
  output Integer status;
end oms_setTLMSocketData;

oms_setTempDirectory

function oms_setTempDirectory
  input String newTempDir;
  output Integer status;
end oms_setTempDirectory;

oms_setTolerance

function oms_setTolerance
  input String cref;
  input Real absoluteTolerance;
  input Real relativeTolerance;
  output Integer status;
end oms_setTolerance;

oms_setVariableStepSize

function oms_setVariableStepSize
  input String cref;
  input Real initialStepSize;
  input Real minimumStepSize;
  input Real maximumStepSize;
  output Integer status;
end oms_setVariableStepSize;

oms_setWorkingDirectory

function oms_setWorkingDirectory
  input String newWorkingDir;
  output Integer status;
end oms_setWorkingDirectory;

oms_simulate

function oms_simulate
  input String cref;
  output Integer status;
end oms_simulate;

oms_stepUntil

function oms_stepUntil
  input String cref;
  input Real stopTime;
  output Integer status;
end oms_stepUntil;

oms_terminate

function oms_terminate
  input String cref;
  output Integer status;
end oms_terminate;

optimize

optimize a modelica/optimica model by generating c code, build it and run the optimization executable.
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [stepSize], [tolerance], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
simulate(A);

function optimize
  input TypeName className "the class that should simulated";
  input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real stepSize = 0.002 "step size that is used for the result file. <default> = 0.002";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = DAE.SCONST("optimization") "optimize a modelica/optimica model.";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
  input Boolean storeInTemp = false "storeInTemp. <default> = false";
  input Boolean noClean = false "noClean. <default> = false";
  input String options = "<default>" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "<default>" "cflags. <default> = \"\"";
  input String simflags = "<default>" "simflags. <default> = \"\"";
  output String optimizationResults;
end optimize;

parseEncryptedPackage

function parseEncryptedPackage
  input String fileName;
  input String workdir = "<default>" "The output directory for imported encrypted files. <default> will put the files to current working directory.";
  output TypeName names[:];
end parseEncryptedPackage;

parseFile

function parseFile
  input String filename;
  input String encoding = "UTF-8";
  output TypeName names[:];
end parseFile;

parseString

function parseString
  input String data;
  input String filename = "<interactive>";
  output TypeName names[:];
end parseString;

plot

Launches a plot window using OMPlot.

function plot
  input VariableNames vars "The variables you want to plot";
  input Boolean externalWindow = false "Opens the plot in a new plot window";
  input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
  input String title = "" "This text will be used as the diagram title.";
  input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
  input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
  input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
  input String xLabel = "time" "This text will be used as the horizontal label in the diagram.";
  input String yLabel = "" "This text will be used as the vertical label in the diagram.";
  input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real curveWidth = 1.0 "Sets the width of the curve.";
  input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
  input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
  input String footer = "" "This text will be used as the diagram footer.";
  input Boolean autoScale = true "Use auto scale while plotting.";
  input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
  output Boolean success "Returns true on success";
end plot;

plotAll

Works in the same way as plot(), but does not accept any
variable names as input. Instead, all variables are part of the plot window.
Example command sequences:
simulate(A);plotAll();
simulate(A);plotAll(externalWindow=true);
simulate(A,fileNamePrefix="B");simulate(C);plotAll(x,fileName="B.mat");

function plotAll
  input Boolean externalWindow = false "Opens the plot in a new plot window";
  input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
  input String title = "" "This text will be used as the diagram title.";
  input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
  input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
  input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
  input String xLabel = "time" "This text will be used as the horizontal label in the diagram.";
  input String yLabel = "" "This text will be used as the vertical label in the diagram.";
  input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real curveWidth = 1.0 "Sets the width of the curve.";
  input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
  input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
  input String footer = "" "This text will be used as the diagram footer.";
  input Boolean autoScale = true "Use auto scale while plotting.";
  input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
  output Boolean success "Returns true on success";
end plotAll;

plotParametric

Launches a plotParametric window using OMPlot. Returns true on success.
Example command sequences:
simulate(A);plotParametric(x,y);
simulate(A);plotParametric(x,y, externalWindow=true);

function plotParametric
  input VariableName xVariable;
  input VariableName yVariable;
  input Boolean externalWindow = false "Opens the plot in a new plot window";
  input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
  input String title = "" "This text will be used as the diagram title.";
  input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
  input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
  input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
  input String xLabel = "" "This text will be used as the horizontal label in the diagram.";
  input String yLabel = "" "This text will be used as the vertical label in the diagram.";
  input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
  input Real curveWidth = 1.0 "Sets the width of the curve.";
  input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
  input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
  input String footer = "" "This text will be used as the diagram footer.";
  input Boolean autoScale = true "Use auto scale while plotting.";
  input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
  output Boolean success "Returns true on success";
end plotParametric;

qualifyPath

function qualifyPath
  input TypeName classPath;
  input TypeName path;
  output TypeName qualifiedPath;
end qualifyPath;

readFile

The contents of the given file are returned.
Note that if the function fails, the error message is returned as a string instead of multiple output or similar.

impure function readFile
  input String fileName;
  output String contents;
end readFile;

readFileNoNumeric

Returns the contents of the file, with anything resembling a (real) number stripped out, and at the end adding:
Filter count from number domain: n.
This should probably be changed to multiple outputs; the filtered string and an integer.
Does anyone use this API call?

function readFileNoNumeric
  input String fileName;
  output String contents;
end readFileNoNumeric;

readSimulationResult

Reads a result file, returning a matrix corresponding to the variables and size given.

function readSimulationResult
  input String filename;
  input VariableNames variables "e.g. {a.b, a[1].b[3].c}, or a single VariableName";
  input Integer size = 0 "0=read any size... If the size is not the same as the result-file, this function fails";
  output Real result[:, :];
end readSimulationResult;

readSimulationResultSize

The number of intervals that are present in the output file.

function readSimulationResultSize
  input String fileName;
  output Integer sz;
end readSimulationResultSize;

readSimulationResultVars

Returns the variables in the simulation file; you can use val() and plot() commands using these names.

function readSimulationResultVars
  input String fileName;
  input Boolean readParameters = true;
  input Boolean openmodelicaStyle = false;
  output String[:] vars;
end readSimulationResultVars;

realpath

Get full path name of file or directory name

function realpath
  input String name "Absolute or relative file or directory name";
  output String fullName "Full path of 'name'";
end realpath;

reduceTerms

reduce terms.

function reduceTerms
  input TypeName className "the class that should be built";
  input Real startTime = 0.0 "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "dassl" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "" "fileNamePrefix. <default> = \"\"";
  input String options = "" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "" "cflags. <default> = \"\"";
  input String simflags = "" "simflags. <default> = \"\"";
  input String labelstoCancel = "";
  output String[2] buildModelResults;
end reduceTerms;

regex

Sets the error buffer and returns -1 if the regex does not compile.
The returned result is the same as POSIX regex():
The first value is the complete matched string
The rest are the substrings that you wanted.
For example:
regex(lorem," \([A-Za-z]*\) \([A-Za-z]*\) ",maxMatches=3)
=> {" ipsum dolor ","ipsum","dolor"}
This means if you have n groups, you want maxMatches=n+1

function regex
  input String str;
  input String re;
  input Integer maxMatches = 1 "The maximum number of matches that will be returned";
  input Boolean extended = true "Use POSIX extended or regular syntax";
  input Boolean caseInsensitive = false;
  output Integer numMatches "-1 is an error, 0 means no match, else returns a number 1..maxMatches";
  output String matchedSubstrings[maxMatches] "unmatched strings are returned as empty";
end regex;

regexBool

Returns true if the string matches the regular expression.

function regexBool
  input String str;
  input String re;
  input Boolean extended = true "Use POSIX extended or regular syntax";
  input Boolean caseInsensitive = false;
  output Boolean matches;
end regexBool;

regularFileExists

function regularFileExists
  input String fileName;
  output Boolean exists;
end regularFileExists;

reloadClass

reloads the file associated with the given (loaded class)

function reloadClass
  input TypeName name;
  input String encoding = "UTF-8";
  output Boolean success;
end reloadClass;

remove

removes a file or directory of given path (which may be either relative or absolute).

function remove
  input String path;
  output Boolean success "Returns true on success.";
end remove;

removeComponentModifiers

function removeComponentModifiers
  input TypeName class_;
  input String componentName;
  input Boolean keepRedeclares = false;
  output Boolean success;
end removeComponentModifiers;

removeElementModifiers

function removeElementModifiers
  input TypeName className;
  input String componentName;
  input Boolean keepRedeclares = false;
  output Boolean success;
end removeElementModifiers;

removeExtendsModifiers

function removeExtendsModifiers
  input TypeName className;
  input TypeName baseClassName;
  input Boolean keepRedeclares = false;
  output Boolean success;
end removeExtendsModifiers;

reopenStandardStream

function reopenStandardStream
  input StandardStream _stream;
  input String filename;
  output Boolean success;
end reopenStandardStream;

restoreAST

function restoreAST
  input Integer id;
  output Boolean success;
end restoreAST;

rewriteBlockCall

Function for property modeling, transforms block calls into instantiations for a loaded model

function rewriteBlockCall
  input TypeName className;
  input TypeName inDefs;
  output Boolean success;
end rewriteBlockCall;

runConversionScript

function runConversionScript
  input TypeName packageToConvert;
  input String scriptFile;
  output Boolean success;
end runConversionScript;

runScript

Runs the mos-script specified by the filename.

impure function runScript
  input String fileName "*.mos";
  output String result;
end runScript;

runScriptParallel

function runScriptParallel
  input String scripts[:];
  input Integer numThreads = numProcessors();
  input Boolean useThreads = false;
  output Boolean results[:];
end runScriptParallel;

save

function save
  input TypeName className;
  output Boolean success;
end save;

saveAll

save the entire loaded AST to file.

function saveAll
  input String fileName;
  output Boolean success;
end saveAll;

saveModel

function saveModel
  input String fileName;
  input TypeName className;
  output Boolean success;
end saveModel;

saveTotalModel

Save the className model in a single file, together with all
the other classes that it depends upon, directly and indirectly.
This file can be later reloaded with the loadFile() API function,
which loads className and all the other needed classes into memory.
This is useful to allow third parties to run a certain model (e.g. for debugging)
without worrying about all the library dependencies.
Please note that SaveTotal file is not a valid Modelica .mo file according to the
specification, and cannot be loaded in OMEdit - it can only be loaded with loadFile().

function saveTotalModel
  input String fileName;
  input TypeName className;
  input Boolean stripAnnotations = false;
  input Boolean stripComments = false;
  input Boolean obfuscate = false;
  output Boolean success;
end saveTotalModel;

saveTotalModelDebug

Saves the className model in a single file, together with all other classes
that it depends on. This function uses a naive heuristic based on which
identifiers are used and might save things which are not actually used,
and is meant to be used in cases where the normal saveTotalModel fails.

function saveTotalModelDebug
  input String filename;
  input TypeName className;
  input Boolean stripAnnotations = false;
  input Boolean stripComments = false;
  input Boolean obfuscate = false;
  output Boolean success;
end saveTotalModelDebug;

saveTotalSCode

searchClassNames

Searches for the class name in the all the loaded classes.
Example command:
searchClassNames("ground");
searchClassNames("ground", true);

function searchClassNames
  input String searchText;
  input Boolean findInText = false;
  output TypeName classNames[:];
end searchClassNames;

setAnnotationVersion

Sets the annotation version.

function setAnnotationVersion
  input String annotationVersion;
  output Boolean success;
end setAnnotationVersion;

setCFlags

CFLAGS

function setCFlags
  input String inString;
  output Boolean success;
end setCFlags;

setCXXCompiler

CXX

function setCXXCompiler
  input String compiler;
  output Boolean success;
end setCXXCompiler;

setCheapMatchingAlgorithm

example input: 3

function setCheapMatchingAlgorithm
  input Integer matchingAlgorithm;
  output Boolean success;
end setCheapMatchingAlgorithm;

setClassComment

Sets the class comment.

function setClassComment
  input TypeName class_;
  input String filename;
  output Boolean success;
end setClassComment;

setCommandLineOptions

The input is a regular command-line flag given to OMC, e.g. -d=failtrace or -g=MetaModelica

function setCommandLineOptions
  input String option;
  output Boolean success;
end setCommandLineOptions;

setCompileCommand

function setCompileCommand
  input String compileCommand;
  output Boolean success;
end setCompileCommand;

setCompiler

CC

function setCompiler
  input String compiler;
  output Boolean success;
end setCompiler;

setCompilerFlags

function setCompilerFlags
  input String compilerFlags;
  output Boolean success;
end setCompilerFlags;

setCompilerPath

function setCompilerPath
  input String compilerPath;
  output Boolean success;
end setCompilerPath;

setComponentModifierValue

setDebugFlags

example input: failtrace,-noevalfunc

function setDebugFlags
  input String debugFlags;
  output Boolean success;
end setDebugFlags;

setDefaultOpenCLDevice

Sets the default OpenCL device to be used.

function setDefaultOpenCLDevice
  input Integer defdevid;
  output Boolean success;
end setDefaultOpenCLDevice;

setDocumentationAnnotation

function setDocumentationAnnotation
  input TypeName class_;
  input String info = "";
  input String revisions = "";
  output Boolean bool;
end setDocumentationAnnotation;

setElementAnnotation

function setElementAnnotation
  input TypeName elementName;
  input ExpressionOrModification annotationMod;
  output Boolean success;
end setElementAnnotation;

setElementModifierValue

function setElementModifierValue
  input TypeName className;
  input TypeName elementName;
  input ExpressionOrModification modifier;
  output Boolean success;
end setElementModifierValue;

setElementType

function setElementType
  input TypeName elementName;
  input VariableName typeName;
  output Boolean success;
end setElementType;

setEnvironmentVar

function setEnvironmentVar
  input String var;
  input String value;
  output Boolean success;
end setEnvironmentVar;

setExtendsModifierValue

function setExtendsModifierValue
  input TypeName className;
  input TypeName extendsName;
  input TypeName elementName;
  input ExpressionOrModification modifier;
  output Boolean success;
end setExtendsModifierValue;

setIndexReductionMethod

example input: dynamicStateSelection

function setIndexReductionMethod
  input String method;
  output Boolean success;
end setIndexReductionMethod;

setInitXmlStartValue

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

setInstallationDirectoryPath

Sets the OPENMODELICAHOME environment variable. Use this method instead of setEnvironmentVar.

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

setLanguageStandard

Sets the Modelica Language Standard.

function setLanguageStandard
  input String inVersion;
  output Boolean success;
end setLanguageStandard;

setLinker

function setLinker
  input String linker;
  output Boolean success;
end setLinker;

setLinkerFlags

function setLinkerFlags
  input String linkerFlags;
  output Boolean success;
end setLinkerFlags;

setMatchingAlgorithm

example input: omc

function setMatchingAlgorithm
  input String matchingAlgorithm;
  output Boolean success;
end setMatchingAlgorithm;

setModelicaPath

The Modelica Library Path - MODELICAPATH in the language specification; OPENMODELICALIBRARY in OpenModelica.

function setModelicaPath
  input String modelicaPath;
  output Boolean success;
end setModelicaPath;

setNoSimplify

Sets the noSimplify flag.

function setNoSimplify
  input Boolean noSimplify;
  output Boolean success;
end setNoSimplify;

setOrderConnections

Sets the orderConnection flag.

function setOrderConnections
  input Boolean orderConnections;
  output Boolean success;
end setOrderConnections;

setPlotCommand

function setPlotCommand
  input String plotCommand;
  output Boolean success;
end setPlotCommand;

setPostOptModules

example input: lateInline,inlineArrayEqn,removeSimpleEquations.

function setPostOptModules
  input String modules;
  output Boolean success;
end setPostOptModules;

setPreOptModules

example input: removeFinalParameters,removeSimpleEquations,expandDerOperator

function setPreOptModules
  input String modules;
  output Boolean success;
end setPreOptModules;

setShowAnnotations

function setShowAnnotations
  input Boolean show;
  output Boolean success;
end setShowAnnotations;

setSourceFile

function setSourceFile
  input TypeName class_;
  input String filename;
  output Boolean success;
end setSourceFile;

setTearingMethod

example input: omcTearing

function setTearingMethod
  input String tearingMethod;
  output Boolean success;
end setTearingMethod;

setTempDirectoryPath

function setTempDirectoryPath
  input String tempDirectoryPath;
  output Boolean success;
end setTempDirectoryPath;

setVectorizationLimit

function setVectorizationLimit
  input Integer vectorizationLimit;
  output Boolean success;
end setVectorizationLimit;

simulate

simulates a modelica model by generating c code, build it and run the simulation executable.
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [tolerance], [method], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
simulate(A);

function simulate
  input TypeName className "the class that should simulated";
  input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "<default>" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
  input String options = "<default>" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
  input String cflags = "<default>" "cflags. <default> = \"\"";
  input String simflags = "<default>" "simflags. <default> = \"\"";
  output SimulationResult simulationResults;
  record SimulationResult
    String resultFile;
    String simulationOptions;
    String messages;
    Real timeFrontend;
    Real timeBackend;
    Real timeSimCode;
    Real timeTemplates;
    Real timeCompile;
    Real timeSimulation;
    Real timeTotal;
  end SimulationResult;
end simulate;

solveLinearSystem

Solve A*X = B using dgesv.
Returns for solver dgesv: info>0: Singular for element i. info<0: Bad input.

function solveLinearSystem
  input Real[size(B, 1), size(B, 1)] A;
  input Real[:] B;
  output Real[size(B, 1)] X;
  output Integer info;
end solveLinearSystem;

sortStrings

function sortStrings
  input String arr[:];
  output String sorted[:];
end sortStrings;

stat

impure function stat
  input String fileName;
  output Boolean success;
  output Real fileSize;
  output Real mtime;
end stat;

storeAST

function storeAST
  output Integer id;
end storeAST;

stringReplace

function stringReplace
  input String str;
  input String source;
  input String target;
  output String res;
end stringReplace;

stringSplit

Splits the string at the places given by the character

function stringSplit
  input String string;
  input String token "single character only";
  output String[:] strings;
end stringSplit;

stringTypeName

function stringTypeName
  input String str;
  output TypeName cl;
end stringTypeName;

stringVariableName

function stringVariableName
  input String str;
  output VariableName cl;
end stringVariableName;

strtok

Splits the strings at the places given by the token, for example:
strtok("abcbdef","b") => {"a","c","def"}
strtok("abcbdef","cd") => {"ab","ef"}

function strtok
  input String string;
  input String token;
  output String[:] strings;
end strtok;

system

Similar to system(3). Executes the given command in the system shell.

impure function system
  input String callStr "String to call: sh -c $callStr";
  input String outputFile = "" "The output is redirected to this file (unless already done by callStr)";
  output Integer retval "Return value of the system call; usually 0 on success";
end system;

system_parallel

Similar to system(3). Executes the given commands in the system shell, in parallel if omc was compiled using OpenMP.

impure function system_parallel
  input String callStr[:] "String to call: sh -c $callStr";
  input Integer numThreads = numProcessors();
  output Integer retval[:] "Return value of the system call; usually 0 on success";
end system_parallel;

testsuiteFriendlyName

function testsuiteFriendlyName
  input String path;
  output String fixed;
end testsuiteFriendlyName;

threadWorkFailed

translateGraphics

function translateGraphics
  input TypeName className;
  output String result;
end translateGraphics;

translateModel

Translates a modelica model into C code without building it.

function translateModel
  input TypeName className "the class that should be built";
  input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
  input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
  input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
  input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
  input String method = "<default>" "integration method used for simulation. <default> = dassl";
  input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
  input String options = "<default>" "options. <default> = \"\"";
  input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
  input String variableFilter = ".*" "Filter for variables that should store in result file. <default> = \".*\"";
  input String cflags = "<default>" "cflags. <default> = \"\"";
  input String simflags = "<default>" "simflags. <default> = \"\"";
  output Boolean success;
end translateModel;

typeNameString

function typeNameString
  input TypeName cl;
  output String out;
end typeNameString;

typeNameStrings

function typeNameStrings
  input TypeName cl;
  output String out[:];
end typeNameStrings;

typeOf

function typeOf
  input VariableName variableName;
  output String result;
end typeOf;

unloadOMSimulator

free the OMSimulator instances

function unloadOMSimulator
  output Integer status;
end unloadOMSimulator;

updateConnection

function updateConnection
  input TypeName className;
  input String from;
  input String to;
  input ExpressionOrModification annotate;
  output Boolean result;
end updateConnection;

updateConnectionAnnotation

function updateConnectionAnnotation
  input TypeName className;
  input String from;
  input String to;
  input String annotate;
  output Boolean result;
end updateConnectionAnnotation;

updateConnectionNames

function updateConnectionNames
  input TypeName className;
  input String from;
  input String to;
  input String fromNew;
  input String toNew;
  output Boolean result;
end updateConnectionNames;

updateInitialState

function updateInitialState
  input TypeName cl;
  input String state;
  input ExpressionOrModification annotate;
  output Boolean bool;
end updateInitialState;

updatePackageIndex

function updatePackageIndex
  output Boolean result;
end updatePackageIndex;

updateTransition

function updateTransition
  input TypeName cl;
  input String from;
  input String to;
  input String oldCondition;
  input Boolean oldImmediate;
  input Boolean oldReset;
  input Boolean oldSynchronize;
  input Integer oldPriority;
  input String newCondition;
  input Boolean newImmediate;
  input Boolean newReset;
  input Boolean newSynchronize;
  input Integer newPriority;
  input ExpressionOrModification annotate;
  output Boolean bool;
end updateTransition;

upgradeInstalledPackages

function upgradeInstalledPackages
  input Boolean installNewestVersions = true;
  output Boolean result;
end upgradeInstalledPackages;

uriToFilename

function uriToFilename
  input String uri;
  output String filename = "";
end uriToFilename;

val

Return the value of a variable at a given time in the simulation results

function val
  input VariableName var;
  input Real timePoint = 0.0;
  input String fileName = "<default>" "The contents of the currentSimulationResult variable";
  output Real valAtTime;
end val;

verifyCompiler

function verifyCompiler
  output Boolean compilerWorks;
end verifyCompiler;

writeFile

Write the data to file. Returns true on success.

impure function writeFile
  input String fileName;
  input String data;
  input Boolean append = false;
  output Boolean success;
end writeFile;

Simulation Parameter Sweep

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

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.

Examples

The following is an interactive session with the OpenModelica environment including some of the abovementioned commands and examples. Run the examples below using OMShell or OMNotebook.

We type in a very small model in the command window:

model Test "Testing OpenModelica Scripts"
  Real x, y;
equation
  x = 5.0+time; y = 6.0;
end Test;

We give the command to flatten a model:

>>> instantiateModel(Test)
class Test "Testing OpenModelica Scripts"
  Real x;
  Real y;
equation
  x = 5.0 + time;
  y = 6.0;
end Test;

A range expression is typed in:

>>> a:=1:10
{1,2,3,4,5,6,7,8,9,10}

It is multiplied by 2:

>>> a*2
{2,4,6,8,10,12,14,16,18,20}

The variables are cleared:

>>> clearVariables()
true

We print the loaded class test from its internal representation:

>>> list(Test)
model Test "Testing OpenModelica Scripts"
  Real x, y;
equation
  x = 5.0 + time;
  y = 6.0;
end Test;

We get the name and other properties of a class:

>>> getClassNames()
{Test,ProfilingTest}
>>> getClassComment(Test)
"Testing OpenModelica Scripts"
>>> isPartial(Test)
false
>>> isPackage(Test)
false
>>> isModel(Test)
true
>>> checkModel(Test)
"Check of Test completed successfully.
Class Test has 2 equation(s) and 2 variable(s).
2 of these are trivial equation(s)."

The common combination of a simulation followed by getting a value and doing a plot:

>>> simulate(Test, stopTime=3.0)
record SimulationResult
    resultFile = "«DOCHOME»/Test_res.mat",
    simulationOptions = "startTime = 0.0, stopTime = 3.0, numberOfIntervals = 500, tolerance = 1e-6, method = 'dassl', fileNamePrefix = 'Test', options = '', outputFormat = 'mat', variableFilter = '.*', cflags = '', simflags = ''",
    messages = "LOG_SUCCESS       | info    | The initialization finished successfully without homotopy method.
LOG_SUCCESS       | info    | The simulation finished successfully.
LOG_STDOUT        | info    | Time measurements are stored in Test_prof.html (human-readable) and Test_prof.xml (for XSL transforms or more details)
",
    timeFrontend = 0.010145754,
    timeBackend = 0.00245288,
    timeSimCode = 9.20811e-4,
    timeTemplates = 0.0036120910000000004,
    timeCompile = 0.587694873,
    timeSimulation = 0.025320089,
    timeTotal = 0.630265208
end SimulationResult;
>>> val(x , 2.0)
7.0

Figure 140 Plot generated by OpenModelica+gnuplot

>>> plotAll()

Figure 141 Plot generated by OpenModelica+gnuplot

Interactive Function Calls, Reading, and Writing

We enter an assignment of a vector expression, created by the range construction expression 1:12, to be stored in the variable x. The type and the value of the expression is returned.

>>> x := 1:12
{1,2,3,4,5,6,7,8,9,10,11,12}

The function bubblesort is called to sort this vector in descending order. The sorted result is returned together with its type. Note that the result vector is of type Real[:], instantiated as Real[12], since this is the declared type of the function result. The input Integer vector was automatically converted to a Real vector according to the Modelica type coercion rules.

>>> loadFile(getInstallationDirectoryPath() + "/share/doc/omc/testmodels/bubblesort.mo")
true
>>> bubblesort(x)
{12.0,11.0,10.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0,1.0}

Now we want to try another small application, a simplex algorithm for optimization. First read in a small matrix containing coefficients that define a simplex problem to be solved:

>>> a := {
  {-1,-1,-1, 0, 0, 0, 0, 0, 0},
  {-1, 1, 0, 1, 0, 0, 0, 0, 5},
  { 1, 4, 0, 0, 1, 0, 0, 0, 45},
  { 2, 1, 0, 0, 0, 1, 0, 0, 27},
  { 3,-4, 0, 0, 0, 0, 1, 0, 24},
  { 0, 0, 1, 0, 0, 0, 0, 1, 4}
}
{{-1,-1,-1,0,0,0,0,0,0},{-1,1,0,1,0,0,0,0,5},{1,4,0,0,1,0,0,0,45},{2,1,0,0,0,1,0,0,27},{3,-4,0,0,0,0,1,0,24},{0,0,1,0,0,0,0,1,4}}

function pivot1
  input Real b[:,:];
  input Integer p;
  input Integer q;
  output Real a[size(b,1),size(b,2)];
protected
  Integer M;
  Integer N;
algorithm
  a := b;
  N := size(a,1)-1;
  M := size(a,2)-1;
  for j in 1:N loop
    for k in 1:M loop
      if j<>p and k<>q then
       a[j,k] := a[j,k]-0.3*j;
      end if;
    end for;
  end for;
  a[p,q] := 0.05;
end pivot1;

function misc_simplex1
  input Real matr[:,:];
  output Real x[size(matr,2)-1];
  output Real z;
  output  Integer q;
  output  Integer p;
protected
  Real a[size(matr,1),size(matr,2)];
  Integer M;
  Integer N;
algorithm
  N := size(a,1)-1;
  M := size(a,2)-1;
  a := matr;
  p:=0;q:=0;
  a := pivot1(a,p+1,q+1);
  while not (q==(M) or p==(N)) loop
    q := 0;
    while not (q == (M) or a[0+1,q+1]>1) loop
      q:=q+1;
    end while;
    p := 0;
    while not (p == (N) or a[p+1,q+1]>0.1) loop
      p:=p+1;
    end while;
    if (q < M) and (p < N) and(p>0) and (q>0) then
      a := pivot1(a,p,q);
    end if;
  if(p<=0) and (q<=0) then
     a := pivot1(a,p+1,q+1);
  end if;
  if(p<=0) and (q>0) then
     a := pivot1(a,p+1,q);
  end if;
  if(p>0) and (q<=0) then
     a := pivot1(a,p,q+1);
  end if;
  end while;
  z := a[1,M];
  x := {a[1,i] for i in 1:size(x,1)};
  for i in 1:10 loop
   for j in 1:M loop
    x[j] := x[j]+x[j]*0.01;
   end for;
  end for;
end misc_simplex1;

Then call the simplex algorithm implemented as the Modelica function simplex1. This function returns four results, which are represented as a tuple of four return values:

>>> misc_simplex1(a)
({0.05523110627056022,-1.1046221254112045,-1.1046221254112045,0.0,0.0,0.0,0.0,0.0},0.0,8,1)