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:
simulate(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(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";
  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;
  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;

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;

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-06, 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.002625941,
    timeBackend = 0.010252983,
    timeSimCode = 0.000980051,
    timeTemplates = 0.003651801,
    timeCompile = 0.571902278,
    timeSimulation = 0.02885194,
    timeTotal = 0.6183970640000001
end SimulationResult;
>>> val(x , 2.0)
7.0

_images/testmodel.svg — Figure 140 Plot generated by OpenModelica+gnuplot¶

>>> plotAll()

_images/testmodel-plotall.svg — 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.104622125411205,-1.104622125411205,0.0,0.0,0.0,0.0,0.0},0.0,8,1)