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;
addComponent¶
function addComponent
input TypeName componentName;
input TypeName typeName;
input TypeName classPath;
input Expression binding = $Code(());
input ExpressionOrModification modification = $Code();
input Expression comment = $Code(());
input Expression annotate = $Code(());
output Boolean success;
end addComponent;
addConnection¶
function addConnection
input VariableName connector1;
input VariableName connector2;
input TypeName className;
input Expression comment = $Code(());
input Expression annotate = $Code(());
output Boolean success;
end addConnection;
addInitialState¶
function addInitialState
input TypeName cl;
input String state;
input ExpressionOrModification annotate;
output Boolean bool;
end addInitialState;
addTransition¶
function addTransition
input TypeName cl;
input String from;
input String to;
input String condition;
input Boolean immediate = true;
input Boolean reset = true;
input Boolean synchronize = false;
input Integer priority = 1;
input ExpressionOrModification annotate;
output Boolean bool;
end addTransition;
alarm¶
impure function alarm
input Integer seconds;
output Integer previousSeconds;
end alarm;
appendEnvironmentVar¶
Appends a variable to the environment variables list.
function appendEnvironmentVar
input String var;
input String value;
output String result "returns \"error\" if the variable could not be appended";
end appendEnvironmentVar;
basename¶
function basename
input String path;
output String basename;
end basename;
buildEncryptedPackage¶
function buildEncryptedPackage
input TypeName className "the class that should encrypted";
input Boolean encrypt = true;
output Boolean success;
end buildEncryptedPackage;
buildLabel¶
builds Label.
function buildLabel
input TypeName className "the class that should be built";
input Real startTime = 0.0 "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = "dassl" "integration method used for simulation. <default> = dassl";
input String fileNamePrefix = "" "fileNamePrefix. <default> = \"\"";
input String options = "" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
input String cflags = "" "cflags. <default> = \"\"";
input String simflags = "" "simflags. <default> = \"\"";
output String[2] buildModelResults;
end buildLabel;
buildModel¶
builds a modelica model by generating c code and build it.
It does not run the code!
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [tolerance], [method], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
buildModel(A);
function buildModel
input TypeName className "the class that should be built";
input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = "<default>" "integration method used for simulation. <default> = dassl";
input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
input String options = "<default>" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
input String cflags = "<default>" "cflags. <default> = \"\"";
input String simflags = "<default>" "simflags. <default> = \"\"";
output String[2] buildModelResults;
end buildModel;
buildModelFMU¶
translates a modelica model into a Functional Mockup Unit.
The only required argument is the className, while all others have some default values.
Example command:
buildModelFMU(className, version="2.0");
function buildModelFMU
input TypeName className "the class that should translated";
input String version = "2.0" "FMU version, 1.0 or 2.0.";
input String fmuType = "me" "FMU type, me (model exchange), cs (co-simulation), me_cs (both model exchange and co-simulation)";
input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"className\"";
input String platforms[:] = {"static"} "The list of platforms to generate code for.
\"dynamic\"=current platform, dynamically link the runtime.
\"static\"=current platform, statically link everything.
\"<cpu>-<vendor>-<os>\", host tripple, e.g. \"x86_64-linux-gnu\" or \"x86_64-w64-mingw32\".
\"<cpu>-<vendor>-<os> docker run <image>\" host tripple with Docker image, e.g. \"x86_64-linux-gnu docker run --pull=never multiarch/crossbuild\"";
input Boolean includeResources = false "Depreacted and no effect";
output String generatedFileName "Returns the full path of the generated FMU.";
end buildModelFMU;
cd¶
change directory to the given path (which may be either relative or absolute)
returns the new working directory on success or a message on failure
if the given path is the empty string, the function simply returns the current working directory.
function cd
input String newWorkingDirectory = "";
output String workingDirectory;
end cd;
checkAllModelsRecursive¶
Checks all models recursively and returns number of variables and equations.
function checkAllModelsRecursive
input TypeName className;
input Boolean checkProtected = false "Checks also protected classes if true";
output String result;
end checkAllModelsRecursive;
checkCodeGraph¶
Checks if the given taskgraph has the same structure as the graph described in the codefile.
function checkCodeGraph
input String graphfile;
input String codefile;
output String[:] result;
end checkCodeGraph;
checkInterfaceOfPackages¶
function checkInterfaceOfPackages
input TypeName cl;
input String dependencyMatrix[:, :];
output Boolean success;
end checkInterfaceOfPackages;
checkModel¶
Checks a model and returns number of variables and equations.
function checkModel
input TypeName className;
output String result;
end checkModel;
checkSettings¶
Display some diagnostics.
function checkSettings
output CheckSettingsResult result;
end checkSettings;
checkTaskGraph¶
Checks if the given taskgraph has the same structure as the reference taskgraph and if all attributes are set correctly.
function checkTaskGraph
input String filename;
input String reffilename;
output String[:] result;
end checkTaskGraph;
classAnnotationExists¶
Check if annotation exists
function classAnnotationExists
input TypeName className;
input TypeName annotationName;
output Boolean exists;
end classAnnotationExists;
clear¶
Clears everything: symboltable and variables.
function clear
output Boolean success;
end clear;
clearCommandLineOptions¶
Resets all command-line flags to their default values.
function clearCommandLineOptions
output Boolean success;
end clearCommandLineOptions;
clearDebugFlags¶
Resets all debug flags to their default values.
function clearDebugFlags
output Boolean success;
end clearDebugFlags;
clearMessages¶
Clears the error buffer.
function clearMessages
output Boolean success;
end clearMessages;
clearProgram¶
Clears loaded .
function clearProgram
output Boolean success;
end clearProgram;
clearVariables¶
Clear all user defined variables.
function clearVariables
output Boolean success;
end clearVariables;
closeSimulationResultFile¶
Closes the current simulation result file.
Only needed by Windows. Windows cannot handle reading and writing to the same file from different processes.
To allow OMEdit to make successful simulation again on the same file we must close the file after reading the Simulation Result Variables.
Even OMEdit only use this API for Windows.
function closeSimulationResultFile
output Boolean success;
end closeSimulationResultFile;
codeToString¶
function codeToString
input $Code className;
output String string;
end codeToString;
compareFiles¶
impure function compareFiles
input String file1;
input String file2;
output Boolean isEqual;
end compareFiles;
compareFilesAndMove¶
impure function compareFilesAndMove
input String newFile;
input String oldFile;
output Boolean success;
end compareFilesAndMove;
convertPackageToLibrary¶
function convertPackageToLibrary
input TypeName packageToConvert;
input TypeName library;
input String libraryVersion;
output Boolean success;
end convertPackageToLibrary;
convertUnits¶
function convertUnits
input String s1;
input String s2;
output Boolean unitsCompatible;
output Real scaleFactor;
output Real offset;
end convertUnits;
copy¶
copies the source file to the destination file. Returns true if the file has been copied.
function copy
input String source;
input String destination;
output Boolean success;
end copy;
copyClass¶
Copies a class within the same level
function copyClass
input TypeName className "the class that should be copied";
input String newClassName "the name for new class";
input TypeName withIn = $Code(__OpenModelica_TopLevel) "the with in path for new class";
output Boolean result;
end copyClass;
countMessages¶
function countMessages
output Integer numMessages;
output Integer numErrors;
output Integer numWarnings;
end countMessages;
createModel¶
function createModel
input TypeName className;
output Boolean success;
end createModel;
deleteClass¶
function deleteClass
input TypeName className;
output Boolean success;
end deleteClass;
deleteComponent¶
function deleteComponent
input TypeName componentName;
input TypeName classPath;
output Boolean success;
end deleteComponent;
deleteConnection¶
function deleteConnection
input VariableName connector1;
input VariableName connector2;
input TypeName className;
output Boolean success;
end deleteConnection;
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;
input String 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;
existClass¶
function existClass
input TypeName cl;
output Boolean exists;
end existClass;
existModel¶
existPackage¶
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 "Not implemented";
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 className;
input String annotationName;
input String modifierName;
output String modifierValue;
end getAnnotationModifierValue;
getAnnotationNamedModifiers¶
function getAnnotationNamedModifiers
input TypeName className;
input String annotationName;
output String[:] modifierNames;
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;
getComponentAnnotations¶
function getComponentAnnotations
input TypeName className;
output Expression result;
end getComponentAnnotations;
getComponentComment¶
function getComponentComment
input TypeName className;
input TypeName componentName;
output String comment;
end getComponentComment;
getComponentCount¶
function getComponentCount
input TypeName classPath;
output Integer count;
end getComponentCount;
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;
getComponents¶
function getComponents
input TypeName className;
input Boolean useQuotes = false;
end getComponents;
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;
getConnectorCount¶
function getConnectorCount
input TypeName className;
output Integer count;
end getConnectorCount;
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;
getDiagramAnnotation¶
function getDiagramAnnotation
input TypeName className;
output Expression result;
end getDiagramAnnotation;
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;
getElementAnnotations¶
function getElementAnnotations
input TypeName className;
output Expression result;
end getElementAnnotations;
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;
getElements¶
function getElements
input TypeName className;
input Boolean useQuotes = false;
end getElements;
getEnumerationLiterals¶
function getEnumerationLiterals
input TypeName className;
output String[:] result;
end getEnumerationLiterals;
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;
getExtendsModifierNames¶
function getExtendsModifierNames
input TypeName className;
input TypeName extendsName;
input Boolean useQuotes = false;
output String modifiers;
end getExtendsModifierNames;
getExternalFunctionSpecification¶
function getExternalFunctionSpecification
input TypeName functionName;
output Expression result;
end getExternalFunctionSpecification;
getHomeDirectoryPath¶
This returns the path to user HOME directory.
function getHomeDirectoryPath
output String homeDirectoryPath;
end getHomeDirectoryPath;
getIconAnnotation¶
function getIconAnnotation
input TypeName className;
output Expression result;
end getIconAnnotation;
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;
getInheritanceCount¶
function getInheritanceCount
input TypeName className;
output Integer count;
end getInheritanceCount;
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;
getNamedAnnotation¶
function getNamedAnnotation
input TypeName className;
input TypeName annotationName;
output Expression result;
end getNamedAnnotation;
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;
getNthComponent¶
function getNthComponent
input TypeName className;
input Integer n;
output Expression result;
end getNthComponent;
getNthComponentAnnotation¶
function getNthComponentAnnotation
input TypeName className;
input Integer n;
output Expression result;
end getNthComponentAnnotation;
getNthComponentCondition¶
function getNthComponentCondition
input TypeName className;
input Integer n;
output String result;
end getNthComponentCondition;
getNthComponentModification¶
function getNthComponentModification
input TypeName className;
input Integer n;
output ExpressionOrModification result[:];
end getNthComponentModification;
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;
getNthConnectionAnnotation¶
function getNthConnectionAnnotation
input TypeName className;
input Integer index;
output Expression result;
end getNthConnectionAnnotation;
getNthConnector¶
function getNthConnector
input TypeName className;
input Integer n;
output Expression result;
end getNthConnector;
getNthConnectorIconAnnotation¶
function getNthConnectorIconAnnotation
input TypeName className;
input Integer n;
output Expression result;
end getNthConnectorIconAnnotation;
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;
getNthInheritedClass¶
function getNthInheritedClass
input TypeName className;
input Integer n;
output TypeName baseClass;
end getNthInheritedClass;
getNthInheritedClassDiagramMapAnnotation¶
function getNthInheritedClassDiagramMapAnnotation
input TypeName className;
input Integer n;
output Expression result;
end getNthInheritedClassDiagramMapAnnotation;
getNthInheritedClassIconMapAnnotation¶
function getNthInheritedClassIconMapAnnotation
input TypeName className;
input Integer n;
output Expression result;
end getNthInheritedClassIconMapAnnotation;
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;
getShortDefinitionBaseClassInformation¶
function getShortDefinitionBaseClassInformation
input TypeName className;
output Expression result;
end getShortDefinitionBaseClassInformation;
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;
isConstant¶
function isConstant
input TypeName componentName;
input TypeName className;
output Boolean result;
end isConstant;
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;
isParameter¶
function isParameter
input TypeName componentName;
input TypeName className;
output Boolean result;
end isParameter;
isPartial¶
function isPartial
input TypeName cl;
output Boolean b;
end isPartial;
isPrimitive¶
function isPrimitive
input TypeName className;
output Boolean result;
end isPrimitive;
isProtected¶
function isProtected
input TypeName componentName;
input TypeName className;
output Boolean result;
end isProtected;
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.";
input Boolean allowWithin = true "Whether to allow the file to have a within-clause other than 'within;'.";
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.";
input Boolean allowWithin = true "Whether to allow the files to have a within-clause other than 'within;'.";
output Boolean success;
end loadFiles;
loadModel¶
Loads the Modelica Standard Library.
function loadModel
input TypeName className;
input String[:] priorityVersion = {"default"};
input Boolean notify = false "Give a notification of the libraries and versions that were loaded";
input String languageStandard = "" "Override the set language standard. Parse with the given setting, but do not change it permanently.";
input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
output Boolean success;
end loadModel;
loadModelica3D¶
function loadModelica3D
input String version = "3.2.1";
output Boolean status;
end loadModelica3D;
loadOMSimulator¶
loads the OMSimulator DLL from default path
function loadOMSimulator
output Integer status;
end loadOMSimulator;
loadString¶
Parses the data and merges the resulting AST with ithe
loaded AST.
If a filename is given, it is used to provide error-messages as if the string
was read in binary format from a file with the same name.
The file is converted to UTF-8 from the given character set.
When merge is true the classes cNew in the file will be merged with the already loaded classes cOld in the following way:
1. get all the inner class definitions from cOld that were loaded from a different file than itself
2. append all elements from step 1 to class cNew public list
NOTE: Encoding is deprecated as *ALL* strings are now UTF-8 encoded.
function loadString
input String data;
input String filename = "<interactive>";
input String encoding = "UTF-8" "Deprecated as *ALL* strings are now UTF-8 encoded";
input Boolean merge = false "if merge is true the parsed AST is merged with the existing AST, default to false which means that is replaced, not merged";
input Boolean uses = true;
input Boolean notify = true "Give a notification of the libraries and versions that were loaded";
input Boolean requireExactVersion = false "If the version is required to be exact, if there is a uses Modelica(version=\"3.2\"), Modelica 3.2.1 will not match it.";
output Boolean success;
end loadString;
mkdir¶
create directory of given path (which may be either relative or absolute)
returns true if directory was created or already exists.
function mkdir
input String newDirectory;
output Boolean success;
end mkdir;
modifierToJSON¶
Parses a modifier given as a string and dumps it as JSON.
function modifierToJSON
input String modifier;
input Boolean prettyPrint = false;
output String json;
end modifierToJSON;
moveClass¶
Moves a class up or down depending on the given offset, where a positive
offset moves the class down and a negative offset up. The offset is truncated
if the resulting index is outside the class list. It retains the visibility of
the class by adding public/protected sections when needed, and merges sections
of the same type if the class is moved from a section it was alone in. Returns
true if the move was successful, otherwise false.
function moveClass
input TypeName className "the class that should be moved";
input Integer offset "Offset in the class list.";
output Boolean result;
end moveClass;
moveClassToBottom¶
Moves a class to the bottom of its enclosing class. Returns true if the move
was successful, otherwise false.
function moveClassToBottom
input TypeName className;
output Boolean result;
end moveClassToBottom;
moveClassToTop¶
Moves a class to the top of its enclosing class. Returns true if the move
was successful, otherwise false.
function moveClassToTop
input TypeName className;
output Boolean result;
end moveClassToTop;
newModel¶
function newModel
input TypeName className;
input TypeName withinPath;
output Boolean success;
end newModel;
ngspicetoModelica¶
Converts ngspice netlist to Modelica code. Modelica file is created in the same directory as netlist file.
function ngspicetoModelica
input String netlistfileName;
output Boolean success = false;
end ngspicetoModelica;
numProcessors¶
function numProcessors
output Integer result;
end numProcessors;
oms_RunFile¶
function oms_RunFile
input String filename;
output Integer status;
end oms_RunFile;
oms_addBus¶
function oms_addBus
input String cref;
output Integer status;
end oms_addBus;
oms_addConnection¶
function oms_addConnection
input String crefA;
input String crefB;
output Integer status;
end oms_addConnection;
oms_addConnector¶
function oms_addConnector
input String cref;
input oms_causality causality;
input oms_signal_type type_;
output Integer status;
end oms_addConnector;
oms_addConnectorToBus¶
function oms_addConnectorToBus
input String busCref;
input String connectorCref;
output Integer status;
end oms_addConnectorToBus;
oms_addConnectorToTLMBus¶
function oms_addConnectorToTLMBus
input String busCref;
input String connectorCref;
input String type_;
output Integer status;
end oms_addConnectorToTLMBus;
oms_addDynamicValueIndicator¶
function oms_addDynamicValueIndicator
input String signal;
input String lower;
input String upper;
input Real stepSize;
output Integer status;
end oms_addDynamicValueIndicator;
oms_addEventIndicator¶
function oms_addEventIndicator
input String signal;
output Integer status;
end oms_addEventIndicator;
oms_addExternalModel¶
function oms_addExternalModel
input String cref;
input String path;
input String startscript;
output Integer status;
end oms_addExternalModel;
oms_addSignalsToResults¶
function oms_addSignalsToResults
input String cref;
input String regex;
output Integer status;
end oms_addSignalsToResults;
oms_addStaticValueIndicator¶
function oms_addStaticValueIndicator
input String signal;
input Real lower;
input Real upper;
input Real stepSize;
output Integer status;
end oms_addStaticValueIndicator;
oms_addSubModel¶
function oms_addSubModel
input String cref;
input String fmuPath;
output Integer status;
end oms_addSubModel;
oms_addSystem¶
function oms_addSystem
input String cref;
input oms_system type_;
output Integer status;
end oms_addSystem;
oms_addTLMBus¶
function oms_addTLMBus
input String cref;
input oms_tlm_domain domain;
input Integer dimensions;
input oms_tlm_interpolation interpolation;
output Integer status;
end oms_addTLMBus;
oms_addTLMConnection¶
function oms_addTLMConnection
input String crefA;
input String crefB;
input Real delay;
input Real alpha;
input Real linearimpedance;
input Real angularimpedance;
output Integer status;
end oms_addTLMConnection;
oms_addTimeIndicator¶
function oms_addTimeIndicator
input String signal;
output Integer status;
end oms_addTimeIndicator;
oms_compareSimulationResults¶
function oms_compareSimulationResults
input String filenameA;
input String filenameB;
input String var;
input Real relTol;
input Real absTol;
output Integer status;
end oms_compareSimulationResults;
oms_copySystem¶
function oms_copySystem
input String source;
input String target;
output Integer status;
end oms_copySystem;
oms_delete¶
function oms_delete
input String cref;
output Integer status;
end oms_delete;
oms_deleteConnection¶
function oms_deleteConnection
input String crefA;
input String crefB;
output Integer status;
end oms_deleteConnection;
oms_deleteConnectorFromBus¶
function oms_deleteConnectorFromBus
input String busCref;
input String connectorCref;
output Integer status;
end oms_deleteConnectorFromBus;
oms_deleteConnectorFromTLMBus¶
function oms_deleteConnectorFromTLMBus
input String busCref;
input String connectorCref;
output Integer status;
end oms_deleteConnectorFromTLMBus;
oms_export¶
function oms_export
input String cref;
input String filename;
output Integer status;
end oms_export;
oms_exportDependencyGraphs¶
function oms_exportDependencyGraphs
input String cref;
input String initialization;
input String event;
input String simulation;
output Integer status;
end oms_exportDependencyGraphs;
oms_exportSnapshot¶
function oms_exportSnapshot
input String cref;
output String contents;
output Integer status;
end oms_exportSnapshot;
oms_extractFMIKind¶
function oms_extractFMIKind
input String filename;
output Integer kind;
output Integer status;
end oms_extractFMIKind;
oms_faultInjection¶
function oms_faultInjection
input String signal;
input oms_fault_type faultType;
input Real faultValue;
output Integer status;
end oms_faultInjection;
oms_getBoolean¶
function oms_getBoolean
input String cref;
output Boolean value;
output Integer status;
end oms_getBoolean;
oms_getFixedStepSize¶
function oms_getFixedStepSize
input String cref;
output Real stepSize;
output Integer status;
end oms_getFixedStepSize;
oms_getInteger¶
function oms_getInteger
input String cref;
input Integer value;
output Integer status;
end oms_getInteger;
oms_getModelState¶
function oms_getModelState
input String cref;
output Integer modelState;
output Integer status;
end oms_getModelState;
oms_getReal¶
function oms_getReal
input String cref;
output Real value;
output Integer status;
end oms_getReal;
oms_getSolver¶
function oms_getSolver
input String cref;
output Integer solver;
output Integer status;
end oms_getSolver;
oms_getStartTime¶
function oms_getStartTime
input String cref;
output Real startTime;
output Integer status;
end oms_getStartTime;
oms_getStopTime¶
function oms_getStopTime
input String cref;
output Real stopTime;
output Integer status;
end oms_getStopTime;
oms_getSubModelPath¶
function oms_getSubModelPath
input String cref;
output String path;
output Integer status;
end oms_getSubModelPath;
oms_getSystemType¶
function oms_getSystemType
input String cref;
output Integer type_;
output Integer status;
end oms_getSystemType;
oms_getTolerance¶
function oms_getTolerance
input String cref;
output Real absoluteTolerance;
output Real relativeTolerance;
output Integer status;
end oms_getTolerance;
oms_getVariableStepSize¶
function oms_getVariableStepSize
input String cref;
output Real initialStepSize;
output Real minimumStepSize;
output Real maximumStepSize;
output Integer status;
end oms_getVariableStepSize;
oms_getVersion¶
Returns the version of the OMSimulator.
function oms_getVersion
output String version;
end oms_getVersion;
oms_importFile¶
function oms_importFile
input String filename;
output String cref;
output Integer status;
end oms_importFile;
oms_importSnapshot¶
function oms_importSnapshot
input String cref;
input String snapshot;
output Integer status;
end oms_importSnapshot;
oms_initialize¶
function oms_initialize
input String cref;
output Integer status;
end oms_initialize;
oms_instantiate¶
function oms_instantiate
input String cref;
output Integer status;
end oms_instantiate;
oms_list¶
function oms_list
input String cref;
output String contents;
output Integer status;
end oms_list;
oms_listUnconnectedConnectors¶
function oms_listUnconnectedConnectors
input String cref;
output String contents;
output Integer status;
end oms_listUnconnectedConnectors;
oms_loadSnapshot¶
function oms_loadSnapshot
input String cref;
input String snapshot;
output String newCref;
output Integer status;
end oms_loadSnapshot;
oms_newModel¶
function oms_newModel
input String cref;
output Integer status;
end oms_newModel;
oms_removeSignalsFromResults¶
function oms_removeSignalsFromResults
input String cref;
input String regex;
output Integer status;
end oms_removeSignalsFromResults;
oms_rename¶
function oms_rename
input String cref;
input String newCref;
output Integer status;
end oms_rename;
oms_reset¶
function oms_reset
input String cref;
output Integer status;
end oms_reset;
oms_setBoolean¶
function oms_setBoolean
input String cref;
input Boolean value;
output Integer status;
end oms_setBoolean;
oms_setCommandLineOption¶
function oms_setCommandLineOption
input String cmd;
output Integer status;
end oms_setCommandLineOption;
oms_setFixedStepSize¶
function oms_setFixedStepSize
input String cref;
input Real stepSize;
output Integer status;
end oms_setFixedStepSize;
oms_setInteger¶
function oms_setInteger
input String cref;
input Integer value;
output Integer status;
end oms_setInteger;
oms_setLogFile¶
function oms_setLogFile
input String filename;
output Integer status;
end oms_setLogFile;
oms_setLoggingInterval¶
function oms_setLoggingInterval
input String cref;
input Real loggingInterval;
output Integer status;
end oms_setLoggingInterval;
oms_setLoggingLevel¶
function oms_setLoggingLevel
input Integer logLevel;
output Integer status;
end oms_setLoggingLevel;
oms_setReal¶
function oms_setReal
input String cref;
input Real value;
output Integer status;
end oms_setReal;
oms_setRealInputDerivative¶
function oms_setRealInputDerivative
input String cref;
input Real value;
output Integer status;
end oms_setRealInputDerivative;
oms_setResultFile¶
function oms_setResultFile
input String cref;
input String filename;
input Integer bufferSize;
output Integer status;
end oms_setResultFile;
oms_setSignalFilter¶
function oms_setSignalFilter
input String cref;
input String regex;
output Integer status;
end oms_setSignalFilter;
oms_setSolver¶
function oms_setSolver
input String cref;
input oms_solver solver;
output Integer status;
end oms_setSolver;
oms_setStartTime¶
function oms_setStartTime
input String cref;
input Real startTime;
output Integer status;
end oms_setStartTime;
oms_setStopTime¶
function oms_setStopTime
input String cref;
input Real stopTime;
output Integer status;
end oms_setStopTime;
oms_setTLMPositionAndOrientation¶
function oms_setTLMPositionAndOrientation
input String cref;
input Real x1;
input Real x2;
input Real x3;
input Real A11;
input Real A12;
input Real A13;
input Real A21;
input Real A22;
input Real A23;
input Real A31;
input Real A32;
input Real A33;
output Integer status;
end oms_setTLMPositionAndOrientation;
oms_setTLMSocketData¶
function oms_setTLMSocketData
input String cref;
input String address;
input Integer managerPort;
input Integer monitorPort;
output Integer status;
end oms_setTLMSocketData;
oms_setTempDirectory¶
function oms_setTempDirectory
input String newTempDir;
output Integer status;
end oms_setTempDirectory;
oms_setTolerance¶
function oms_setTolerance
input String cref;
input Real absoluteTolerance;
input Real relativeTolerance;
output Integer status;
end oms_setTolerance;
oms_setVariableStepSize¶
function oms_setVariableStepSize
input String cref;
input Real initialStepSize;
input Real minimumStepSize;
input Real maximumStepSize;
output Integer status;
end oms_setVariableStepSize;
oms_setWorkingDirectory¶
function oms_setWorkingDirectory
input String newWorkingDir;
output Integer status;
end oms_setWorkingDirectory;
oms_simulate¶
function oms_simulate
input String cref;
output Integer status;
end oms_simulate;
oms_stepUntil¶
function oms_stepUntil
input String cref;
input Real stopTime;
output Integer status;
end oms_stepUntil;
oms_terminate¶
function oms_terminate
input String cref;
output Integer status;
end oms_terminate;
optimize¶
optimize a modelica/optimica model by generating c code, build it and run the optimization executable.
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [stepSize], [tolerance], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
simulate(A);
function optimize
input TypeName className "the class that should simulated";
input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real stepSize = 0.002 "step size that is used for the result file. <default> = 0.002";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = DAE.SCONST("optimization") "optimize a modelica/optimica model.";
input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
input Boolean storeInTemp = false "storeInTemp. <default> = false";
input Boolean noClean = false "noClean. <default> = false";
input String options = "<default>" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
input String cflags = "<default>" "cflags. <default> = \"\"";
input String simflags = "<default>" "simflags. <default> = \"\"";
output String optimizationResults;
end optimize;
parseEncryptedPackage¶
function parseEncryptedPackage
input String fileName;
input String workdir = "<default>" "The output directory for imported encrypted files. <default> will put the files to current working directory.";
output TypeName names[:];
end parseEncryptedPackage;
parseFile¶
function parseFile
input String filename;
input String encoding = "UTF-8";
output TypeName names[:];
end parseFile;
parseString¶
function parseString
input String data;
input String filename = "<interactive>";
output TypeName names[:];
end parseString;
plot¶
Launches a plot window using OMPlot.
function plot
input VariableNames vars "The variables you want to plot";
input Boolean externalWindow = false "Opens the plot in a new plot window";
input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
input String title = "" "This text will be used as the diagram title.";
input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
input String xLabel = "time" "This text will be used as the horizontal label in the diagram.";
input String yLabel = "" "This text will be used as the vertical label in the diagram.";
input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real curveWidth = 1.0 "Sets the width of the curve.";
input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
input String footer = "" "This text will be used as the diagram footer.";
input Boolean autoScale = true "Use auto scale while plotting.";
input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
output Boolean success "Returns true on success";
end plot;
plotAll¶
Works in the same way as plot(), but does not accept any
variable names as input. Instead, all variables are part of the plot window.
Example command sequences:
simulate(A);plotAll();
simulate(A);plotAll(externalWindow=true);
simulate(A,fileNamePrefix="B");simulate(C);plotAll(x,fileName="B.mat");
function plotAll
input Boolean externalWindow = false "Opens the plot in a new plot window";
input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
input String title = "" "This text will be used as the diagram title.";
input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
input String xLabel = "time" "This text will be used as the horizontal label in the diagram.";
input String yLabel = "" "This text will be used as the vertical label in the diagram.";
input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real curveWidth = 1.0 "Sets the width of the curve.";
input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
input String footer = "" "This text will be used as the diagram footer.";
input Boolean autoScale = true "Use auto scale while plotting.";
input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
output Boolean success "Returns true on success";
end plotAll;
plotParametric¶
Launches a plotParametric window using OMPlot. Returns true on success.
Example command sequences:
simulate(A);plotParametric(x,y);
simulate(A);plotParametric(x,y, externalWindow=true);
function plotParametric
input VariableName xVariable;
input VariableName yVariable;
input Boolean externalWindow = false "Opens the plot in a new plot window";
input String fileName = "<default>" "The filename containing the variables. <default> will read the last simulation result";
input String title = "" "This text will be used as the diagram title.";
input String grid = "simple" "Sets the grid for the plot i.e simple, detailed, none.";
input Boolean logX = false "Determines whether or not the horizontal axis is logarithmically scaled.";
input Boolean logY = false "Determines whether or not the vertical axis is logarithmically scaled.";
input String xLabel = "" "This text will be used as the horizontal label in the diagram.";
input String yLabel = "" "This text will be used as the vertical label in the diagram.";
input Real xRange[2] = {0.0, 0.0} "Determines the horizontal interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real yRange[2] = {0.0, 0.0} "Determines the vertical interval that is visible in the diagram. {0,0} will select a suitable range.";
input Real curveWidth = 1.0 "Sets the width of the curve.";
input Integer curveStyle = 1 "Sets the style of the curve. SolidLine=1, DashLine=2, DotLine=3, DashDotLine=4, DashDotDotLine=5, Sticks=6, Steps=7.";
input String legendPosition = "top" "Sets the POSITION of the legend i.e left, right, top, bottom, none.";
input String footer = "" "This text will be used as the diagram footer.";
input Boolean autoScale = true "Use auto scale while plotting.";
input Boolean forceOMPlot = false "if true launches OMPlot and doesn't call callback function even if it is defined.";
output Boolean success "Returns true on success";
end plotParametric;
qualifyPath¶
function qualifyPath
input TypeName classPath;
input TypeName path;
output TypeName qualifiedPath;
end qualifyPath;
readFile¶
The contents of the given file are returned.
Note that if the function fails, the error message is returned as a string instead of multiple output or similar.
impure function readFile
input String fileName;
output String contents;
end readFile;
readFileNoNumeric¶
Returns the contents of the file, with anything resembling a (real) number stripped out, and at the end adding:
Filter count from number domain: n.
This should probably be changed to multiple outputs; the filtered string and an integer.
Does anyone use this API call?
function readFileNoNumeric
input String fileName;
output String contents;
end readFileNoNumeric;
readSimulationResult¶
Reads a result file, returning a matrix corresponding to the variables and size given.
function readSimulationResult
input String filename;
input VariableNames variables "e.g. {a.b, a[1].b[3].c}, or a single VariableName";
input Integer size = 0 "0=read any size... If the size is not the same as the result-file, this function fails";
output Real result[:, :];
end readSimulationResult;
readSimulationResultSize¶
The number of intervals that are present in the output file.
function readSimulationResultSize
input String fileName;
output Integer sz;
end readSimulationResultSize;
readSimulationResultVars¶
Returns the variables in the simulation file; you can use val() and plot() commands using these names.
function readSimulationResultVars
input String fileName;
input Boolean readParameters = true;
input Boolean openmodelicaStyle = false;
output String[:] vars;
end readSimulationResultVars;
realpath¶
Get full path name of file or directory name
function realpath
input String name "Absolute or relative file or directory name";
output String fullName "Full path of 'name'";
end realpath;
reduceTerms¶
reduce terms.
function reduceTerms
input TypeName className "the class that should be built";
input Real startTime = 0.0 "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = "dassl" "integration method used for simulation. <default> = dassl";
input String fileNamePrefix = "" "fileNamePrefix. <default> = \"\"";
input String options = "" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
input String cflags = "" "cflags. <default> = \"\"";
input String simflags = "" "simflags. <default> = \"\"";
input String labelstoCancel = "";
output String[2] buildModelResults;
end reduceTerms;
refactorClass¶
function refactorClass
input TypeName className;
output String result;
end refactorClass;
refactorDiagramAnnotation¶
function refactorDiagramAnnotation
input TypeName className;
output Expression result;
end refactorDiagramAnnotation;
refactorIconAnnotation¶
function refactorIconAnnotation
input TypeName className;
output Expression result;
end refactorIconAnnotation;
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;
setComponentComment¶
function setComponentComment
input TypeName className;
input TypeName componentName;
input String comment;
output Boolean success;
end setComponentComment;
setComponentDimensions¶
function setComponentDimensions
input TypeName className;
input TypeName componentName;
input Expression dimensions;
output Boolean success;
end setComponentDimensions;
setComponentModifierValue¶
setConnectionComment¶
function setConnectionComment
input TypeName className;
input VariableName connector1;
input VariableName connector2;
input String comment;
output Boolean success;
end setConnectionComment;
setDebugFlags¶
example input: failtrace,-noevalfunc
function setDebugFlags
input String debugFlags;
output Boolean success;
end setDebugFlags;
setDefaultOpenCLDevice¶
Sets the default OpenCL device to be used.
function setDefaultOpenCLDevice
input Integer defdevid;
output Boolean success;
end setDefaultOpenCLDevice;
setDocumentationAnnotation¶
function setDocumentationAnnotation
input TypeName class_;
input String info = "";
input String revisions = "";
output Boolean bool;
end setDocumentationAnnotation;
setElementAnnotation¶
function setElementAnnotation
input TypeName elementName;
input ExpressionOrModification annotationMod;
output Boolean success;
end setElementAnnotation;
setElementModifierValue¶
function setElementModifierValue
input TypeName className;
input TypeName elementName;
input ExpressionOrModification modifier;
output Boolean success;
end setElementModifierValue;
setElementType¶
function setElementType
input TypeName elementName;
input VariableName typeName;
output Boolean success;
end setElementType;
setEnvironmentVar¶
function setEnvironmentVar
input String var;
input String value;
output Boolean success;
end setEnvironmentVar;
setExtendsModifier¶
function setExtendsModifier
input TypeName className;
input TypeName extendsName;
input ExpressionOrModification modifier;
output Boolean success;
end setExtendsModifier;
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;
setParameterValue¶
function setParameterValue
input TypeName className;
input TypeName variableName;
input Expression value;
end setParameterValue;
setPlotCommand¶
function setPlotCommand
input String plotCommand;
output Boolean success;
end setPlotCommand;
setPostOptModules¶
example input: lateInline,inlineArrayEqn,removeSimpleEquations.
function setPostOptModules
input String modules;
output Boolean success;
end setPostOptModules;
setPreOptModules¶
example input: removeFinalParameters,removeSimpleEquations,expandDerOperator
function setPreOptModules
input String modules;
output Boolean success;
end setPreOptModules;
setShowAnnotations¶
function setShowAnnotations
input Boolean show;
output Boolean success;
end setShowAnnotations;
setSourceFile¶
function setSourceFile
input TypeName class_;
input String filename;
output Boolean success;
end setSourceFile;
setTearingMethod¶
example input: omcTearing
function setTearingMethod
input String tearingMethod;
output Boolean success;
end setTearingMethod;
setTempDirectoryPath¶
function setTempDirectoryPath
input String tempDirectoryPath;
output Boolean success;
end setTempDirectoryPath;
setVectorizationLimit¶
function setVectorizationLimit
input Integer vectorizationLimit;
output Boolean success;
end setVectorizationLimit;
simulate¶
simulates a modelica model by generating c code, build it and run the simulation executable.
The only required argument is the className, while all others have some default values.
simulate(className, [startTime], [stopTime], [numberOfIntervals], [tolerance], [method], [fileNamePrefix], [options], [outputFormat], [variableFilter], [cflags], [simflags])
Example command:
simulate(A);
function simulate
input TypeName className "the class that should simulated";
input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = "<default>" "integration method used for simulation. <default> = dassl";
input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
input String options = "<default>" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "Only variables fully matching the regexp are stored in the result file. <default> = \".*\"";
input String cflags = "<default>" "cflags. <default> = \"\"";
input String simflags = "<default>" "simflags. <default> = \"\"";
output SimulationResult simulationResults;
record SimulationResult
String resultFile;
String simulationOptions;
String messages;
Real timeFrontend;
Real timeBackend;
Real timeSimCode;
Real timeTemplates;
Real timeCompile;
Real timeSimulation;
Real timeTotal;
end SimulationResult;
end simulate;
solveLinearSystem¶
Solve A*X = B using dgesv.
Returns for solver dgesv: info>0: Singular for element i. info<0: Bad input.
function solveLinearSystem
input Real[size(B, 1), size(B, 1)] A;
input Real[:] B;
output Real[size(B, 1)] X;
output Integer info;
end solveLinearSystem;
sortStrings¶
function sortStrings
input String arr[:];
output String sorted[:];
end sortStrings;
stat¶
impure function stat
input String fileName;
output Boolean success;
output Real fileSize;
output Real mtime;
end stat;
storeAST¶
function storeAST
output Integer id;
end storeAST;
stringReplace¶
function stringReplace
input String str;
input String source;
input String target;
output String res;
end stringReplace;
stringSplit¶
Splits the string at the places given by the character
function stringSplit
input String string;
input String token "single character only";
output String[:] strings;
end stringSplit;
stringTypeName¶
function stringTypeName
input String str;
output TypeName cl;
end stringTypeName;
stringVariableName¶
function stringVariableName
input String str;
output VariableName cl;
end stringVariableName;
strtok¶
Splits the strings at the places given by the token, for example:
strtok("abcbdef","b") => {"a","c","def"}
strtok("abcbdef","cd") => {"ab","ef"}
function strtok
input String string;
input String token;
output String[:] strings;
end strtok;
system¶
Similar to system(3). Executes the given command in the system shell.
impure function system
input String callStr "String to call: sh -c $callStr";
input String outputFile = "" "The output is redirected to this file (unless already done by callStr)";
output Integer retval "Return value of the system call; usually 0 on success";
end system;
system_parallel¶
Similar to system(3). Executes the given commands in the system shell, in parallel if omc was compiled using OpenMP.
impure function system_parallel
input String callStr[:] "String to call: sh -c $callStr";
input Integer numThreads = numProcessors();
output Integer retval[:] "Return value of the system call; usually 0 on success";
end system_parallel;
testsuiteFriendlyName¶
function testsuiteFriendlyName
input String path;
output String fixed;
end testsuiteFriendlyName;
threadWorkFailed¶
translateGraphics¶
function translateGraphics
input TypeName className;
output String result;
end translateGraphics;
translateModel¶
Translates a modelica model into C code without building it.
function translateModel
input TypeName className "the class that should be built";
input Real startTime = "<default>" "the start time of the simulation. <default> = 0.0";
input Real stopTime = 1.0 "the stop time of the simulation. <default> = 1.0";
input Integer numberOfIntervals = 500 "number of intervals in the result file. <default> = 500";
input Real tolerance = 1e-6 "tolerance used by the integration method. <default> = 1e-6";
input String method = "<default>" "integration method used for simulation. <default> = dassl";
input String fileNamePrefix = "<default>" "fileNamePrefix. <default> = \"\"";
input String options = "<default>" "options. <default> = \"\"";
input String outputFormat = "mat" "Format for the result file. <default> = \"mat\"";
input String variableFilter = ".*" "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 Boolean success;
end translateModel;
typeNameString¶
function typeNameString
input TypeName cl;
output String out;
end typeNameString;
typeNameStrings¶
function typeNameStrings
input TypeName cl;
output String out[:];
end typeNameStrings;
typeOf¶
function typeOf
input VariableName variableName;
output String result;
end typeOf;
unloadOMSimulator¶
free the OMSimulator instances
function unloadOMSimulator
output Integer status;
end unloadOMSimulator;
updateComponent¶
function updateComponent
input TypeName componentName;
input TypeName typeName;
input TypeName classPath;
input Expression binding = $Code(());
input ExpressionOrModification modification = $Code();
input Expression comment = $Code(());
input Expression annotate = $Code(());
output Boolean success;
end updateComponent;
updateConnection¶
function updateConnection
input TypeName className;
input String from;
input String to;
input ExpressionOrModification annotate;
output Boolean result;
end updateConnection;
updateConnectionAnnotation¶
function updateConnectionAnnotation
input TypeName className;
input String from;
input String to;
input String annotate;
output Boolean result;
end updateConnectionAnnotation;
updateConnectionNames¶
function updateConnectionNames
input TypeName className;
input String from;
input String to;
input String fromNew;
input String toNew;
output Boolean result;
end updateConnectionNames;
updateInitialState¶
function updateInitialState
input TypeName cl;
input String state;
input ExpressionOrModification annotate;
output Boolean bool;
end updateInitialState;
updatePackageIndex¶
function updatePackageIndex
output Boolean result;
end updatePackageIndex;
updateTransition¶
function updateTransition
input TypeName cl;
input String from;
input String to;
input String oldCondition;
input Boolean oldImmediate;
input Boolean oldReset;
input Boolean oldSynchronize;
input Integer oldPriority;
input String newCondition;
input Boolean newImmediate;
input Boolean newReset;
input Boolean newSynchronize;
input Integer newPriority;
input ExpressionOrModification annotate;
output Boolean bool;
end updateTransition;
upgradeInstalledPackages¶
function upgradeInstalledPackages
input Boolean installNewestVersions = true;
output Boolean result;
end upgradeInstalledPackages;
uriToFilename¶
function uriToFilename
input String uri;
output String filename = "";
end uriToFilename;
val¶
Return the value of a variable at a given time in the simulation results
function val
input VariableName var;
input Real timePoint = 0.0;
input String fileName = "<default>" "The contents of the currentSimulationResult variable";
output Real valAtTime;
end val;
verifyCompiler¶
function verifyCompiler
output Boolean compilerWorks;
end verifyCompiler;
writeFile¶
Write the data to file. Returns true on success.
impure function writeFile
input String fileName;
input String data;
input Boolean append = false;
output Boolean success;
end writeFile;
Simulation Parameter Sweep¶
Following example shows how to update the parameters and re-run the simulation without compiling the model.
loadFile("BouncingBall.mo");
getErrorString();
// build the model once
buildModel(BouncingBall);
getErrorString();
for i in 1:3 loop
// We update the parameter e start value from 0.7 to "0.7 + i".
value := 0.7 + i;
// call the generated simulation code to produce a result file BouncingBall%i%_res.mat
system("./BouncingBall -override=e="+String(value)+" -r=BouncingBall" + String(i) + "_res.mat");
getErrorString();
end for;
We used the BouncingBall.mo in the example above. The above example produces three result files each containing different start value for e i.e., 1.7, 2.7, 3.7.
Examples¶
The following is an interactive session with the OpenModelica environment including some of the abovementioned commands and examples. Run the examples below using OMShell or OMNotebook.
We type in a very small model in the command window:
model Test "Testing OpenModelica Scripts"
Real x, y;
equation
x = 5.0+time; y = 6.0;
end Test;
We give the command to flatten a model:
>>> instantiateModel(Test)
class Test "Testing OpenModelica Scripts"
Real x;
Real y;
equation
x = 5.0 + time;
y = 6.0;
end Test;
A range expression is typed in:
>>> a:=1:10
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
It is multiplied by 2:
>>> a*2
{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
The variables are cleared:
>>> clearVariables()
true
We print the loaded class test from its internal representation:
>>> list(Test)
model Test "Testing OpenModelica Scripts"
Real x, y;
equation
x = 5.0 + time;
y = 6.0;
end Test;
We get the name and other properties of a class:
>>> getClassNames()
{Test, ProfilingTest}
>>> getClassComment(Test)
"Testing OpenModelica Scripts"
>>> isPartial(Test)
false
>>> isPackage(Test)
false
>>> isModel(Test)
true
>>> checkModel(Test)
"Check of Test completed successfully.
Class Test has 2 equation(s) and 2 variable(s).
2 of these are trivial equation(s)."
The common combination of a simulation followed by getting a value and doing a plot:
>>> simulate(Test, stopTime=3.0)
record SimulationResult
resultFile = "«DOCHOME»/Test_res.mat",
simulationOptions = "startTime = 0.0, stopTime = 3.0, numberOfIntervals = 500, tolerance = 1e-6, method = 'dassl', fileNamePrefix = 'Test', options = '', outputFormat = 'mat', variableFilter = '.*', cflags = '', simflags = ''",
messages = "LOG_SUCCESS | info | The initialization finished successfully without homotopy method.
LOG_SUCCESS | info | The simulation finished successfully.
LOG_STDOUT | info | Time measurements are stored in Test_prof.html (human-readable) and Test_prof.xml (for XSL transforms or more details)
",
timeFrontend = 0.0020562270000000003,
timeBackend = 0.00229138,
timeSimCode = 8.41072e-4,
timeTemplates = 0.002854946,
timeCompile = 0.7462465789999999,
timeSimulation = 0.032917998000000004,
timeTotal = 0.787331645
end SimulationResult;
>>> val(x , 2.0)
7.0
Figure 124 Plot generated by OpenModelica+gnuplot¶
>>> plotAll()
Figure 125 Plot generated by OpenModelica+gnuplot¶
Interactive Function Calls, Reading, and Writing¶
We enter an assignment of a vector expression, created by the range construction expression 1:12, to be stored in the variable x. The type and the value of the expression is returned.
>>> x := 1:12
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
The function bubblesort is called to sort this vector in descending order. The sorted result is returned together with its type. Note that the result vector is of type Real[:], instantiated as Real[12], since this is the declared type of the function result. The input Integer vector was automatically converted to a Real vector according to the Modelica type coercion rules.
>>> loadFile(getInstallationDirectoryPath() + "/share/doc/omc/testmodels/bubblesort.mo")
true
>>> bubblesort(x)
{12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}
Now we want to try another small application, a simplex algorithm for optimization. First read in a small matrix containing coefficients that define a simplex problem to be solved:
>>> a := {
{-1,-1,-1, 0, 0, 0, 0, 0, 0},
{-1, 1, 0, 1, 0, 0, 0, 0, 5},
{ 1, 4, 0, 0, 1, 0, 0, 0, 45},
{ 2, 1, 0, 0, 0, 1, 0, 0, 27},
{ 3,-4, 0, 0, 0, 0, 1, 0, 24},
{ 0, 0, 1, 0, 0, 0, 0, 1, 4}
}
{{-1, -1, -1, 0, 0, 0, 0, 0, 0}, {-1, 1, 0, 1, 0, 0, 0, 0, 5}, {1, 4, 0, 0, 1, 0, 0, 0, 45}, {2, 1, 0, 0, 0, 1, 0, 0, 27}, {3, -4, 0, 0, 0, 0, 1, 0, 24}, {0, 0, 1, 0, 0, 0, 0, 1, 4}}
function pivot1
input Real b[:,:];
input Integer p;
input Integer q;
output Real a[size(b,1),size(b,2)];
protected
Integer M;
Integer N;
algorithm
a := b;
N := size(a,1)-1;
M := size(a,2)-1;
for j in 1:N loop
for k in 1:M loop
if j<>p and k<>q then
a[j,k] := a[j,k]-0.3*j;
end if;
end for;
end for;
a[p,q] := 0.05;
end pivot1;
function misc_simplex1
input Real matr[:,:];
output Real x[size(matr,2)-1];
output Real z;
output Integer q;
output Integer p;
protected
Real a[size(matr,1),size(matr,2)];
Integer M;
Integer N;
algorithm
N := size(a,1)-1;
M := size(a,2)-1;
a := matr;
p:=0;q:=0;
a := pivot1(a,p+1,q+1);
while not (q==(M) or p==(N)) loop
q := 0;
while not (q == (M) or a[0+1,q+1]>1) loop
q:=q+1;
end while;
p := 0;
while not (p == (N) or a[p+1,q+1]>0.1) loop
p:=p+1;
end while;
if (q < M) and (p < N) and(p>0) and (q>0) then
a := pivot1(a,p,q);
end if;
if(p<=0) and (q<=0) then
a := pivot1(a,p+1,q+1);
end if;
if(p<=0) and (q>0) then
a := pivot1(a,p+1,q);
end if;
if(p>0) and (q<=0) then
a := pivot1(a,p,q+1);
end if;
end while;
z := a[1,M];
x := {a[1,i] for i in 1:size(x,1)};
for i in 1:10 loop
for j in 1:M loop
x[j] := x[j]+x[j]*0.01;
end for;
end for;
end misc_simplex1;
Then call the simplex algorithm implemented as the Modelica function simplex1. This function returns four results, which are represented as a tuple of four return values:
>>> misc_simplex1(a)
({0.05523110627056022, -1.1046221254112045, -1.1046221254112045, 0.0, 0.0, 0.0, 0.0, 0.0}, 0.0, 8, 1)
