SystemModel
Listing of Model Components »SystemModel["model"]
gives a representation of the model "model", usable as input to other functions.
SystemModel["model"]["property"]
gives the specified "property" for the model "model".
Details and Options
- SystemModel[…]["property"] is equivalent to SystemModel[…, "property"].
- SystemModel["model"]["Properties"] gives a list of possible properties.
- A shortened name "model" can be used if SystemModels["*.model"] gives a unique match.
- Import["file.mo","MO"] imports the specified model and makes it available as a SystemModel.
- Use Export to save a SystemModel to disk.
- SystemModel[model,<"property"->…>] creates a new SystemModel by modifying property of model.
- Properties related to the whole model:
-
"Description" top-level description of model "Summary" model summary data "ModelName" fully qualified path of model "Diagram" diagram view of model "ModelicaIcon" icon view of model "ModelicaDisplay" show Modelica model code "ModelicaString" Modelica model code as a string "SourceFile" file where the model is saved "Documentation" open model documentation "DocumentationURL" link to model documentation "Domain" association describing modeling domain "DomainChart" chart describing modeling domain "Balanced" if the model is balanced in equations and variables "SimulationModel" if the model is a simulation model "Specialization" specialization "model", "package", "function", … "Version" version information of model "SimulationSettings" model simulation options - "ModelicaDisplay" creates a cell with style "Program" containing the textual form of "model".
- "ModelicaString" returns the textual form of "model" as a string.
- SystemModel["model"]["Diagram","c1","c2",…] shows the diagram for component "c1.c2...ci" in "model".
- SystemModel["model",{property,options}] accepts the following options for property "Diagram" and "ModelicaIcon":
-
Frame True show frame FrameTicks False show frame ticks GridLines None what grid lines to show PlotRange Automatic plot range in mm PlotRangePadding Automatic padding in mm - GridLines->Inherited inherits the grid defined in the model diagram. »
- PlotRange->Automatic specifies a plot range that encloses the primitives drawn in the diagram.
- PlotRange->Inherited inherits the page size specified in the model diagram.
- Properties related to model plots:
-
"PlotNames" names of plots in model "LocalPlotNames" names of plots defined locally in model "InheritedPlotNames" names of plots inherited from "ExtendsModels" "Plots" model plot specifications "LocalPlots" plot specifications defined locally in model "InheritedPlots" plot specifications defined in "ExtendsModels" - Model plots from "Plots" and "LocalPlots" are a list of plotspec.
- Each plotspec is an Association that includes the following keys:
-
"Subplots" {sp1,sp2,…} list of subplots specifications (required) "Identifier" Automatic plot identifier "Name" Automatic name of the plot "Group" None group name "Default" False whether the plot is a default one "Caption" None caption of the plot - Each subplot specification spi is an Association that includes the following keys:
-
"Variables" {v1,v2,…} list of variables (required) "Identifier" None subplot identifier "Title" Automatic title of the subplot "Interval" Automatic time interval "AxesLabel" Automatic axes label "PlotLegends" Automatic legends for curves "PlotRange" Automatic range of values to include - Model plot "Variables" can take the following forms:
-
{"v1","v2",…} variables vi {{"v1,x","v1,y"},…} parametric plot of vi,x vs vi,y {{"v1","p1",d1},…} sensitivity bounds around vi for pi varying 100 di% - Model plot "Interval" can be given as {tmin,tmax} or tmax.
- Model plot "AxesLabel" can be Automatic, None, a string label for the y axis or {"xlabel","ylabel"}.
- Possible "PlotLegends" are Automatic, None or a list of one string per variable in the plot.
- "PlotRange" is Automatic, {ymin,ymax} or y, which is interpreted as {-y,y}.
- If "Default" is True, the plot will be included in SystemModelPlot[model].
- Properties related to equations and variables:
-
"SystemEquations" differential and algebraic equations "InitialEquations" initial value equations "InitialSeedings" guess values for initialization "StateVariables" differentiated variables "AlgebraicVariables" non-differentiated variables "SystemVariables" state and algebraic variables "TopSystemVariables" system variables excluding component variables "InputVariables" variables specified as inputs "OutputVariables" variables specified as outputs "ParameterNames" parameters "TopParameterNames" parameters excluding component parameters "DiscreteVariables" variables changing only at events - "SystemEquations" gives equations depending on t.
- SystemModel["model"]["SystemEquations",t] gives equations depending on t.
- SystemModel[…] contains Missing[type,content] for any parts of equations that cannot be represented.
- "InputVariables" are distinct from "SystemVariables", and "OutputVariables" are a subset of "SystemVariables".
- "DiscreteVariables" are a subset of "SystemVariables" and are given in a form suitable as a setting for the DiscreteVariables option to NDSolve.
- Properties related to values:
-
"ParameterValues" parameter rules {p1->val1,…} "InitialValues" initial value rules {v1->val1,…} "GroupedInitialValues" initial values grouped by states, inputs and outputs "TopParameterValues" top parameter values "TopInitialValues" initial values for top variables - For variable and parameter lists, SystemModel["model"][{prop,patt}] returns the elements of prop whose Modelica form matches the string pattern patt.
- Properties related to the structure of the model:
-
"ExtendsModels" models this model extends "Components" model components "Connections" model connections "Connectors" model connector components "LocalComponents" components defined locally in model "LocalConnections" connections defined locally in model "LocalConnectors" connectors defined locally in model "InheritedComponents" components defined in "ExtendsModels" "InheritedConnections" connections defined in "ExtendsModels" "InheritedConnectors" connectors defined in "ExtendsModels" - Properties related to relations with other models:
-
"ModelsExtending" models that extend this model "ModelsContaining" models that use this model as a component "Parent" the parent model in a package hierarchy "Children" child models in a package hierarchy "Siblings" sibling models in a package hierarchy - The following options can be given:
-
Method Automatic methods for equation processing ProgressReporting $ProgressReporting control display of progress - Possible settings for "opti" in Method->{"opt1"->val1} include:
-
"Elimination" None eliminate simple equations "ReduceIndex" Automatic reduced index of DAEs in balanced models "StartTime" 0 simulation start time - The properties "PropertyAssociation" and "PropertyDataset" return computable forms of all properties.
Examples
open all close allBasic Examples (5)
Get the representation of a model:
SystemModel["IntroductoryExamples.MultiDomain.DCMotor"]Retrieve a property using the model representation:
[image]["Description"][image]["Summary"]Import loads a model from disk using the "MO" format:
model = Import["ExampleData/ExampleModel.mo", "MO"]Get the differential equations for the model:
model["SystemEquations"]Get the differential equations for a model:
[image]["SystemEquations"]Pick a random included example model using SystemModelExamples:
model = RandomChoice[SystemModelExamples["Models"]]Show the full model name and description for the model:
model["ModelName"]model["Description"]Scope (59)
Basic Uses (5)
Show a list of possible properties:
[image]["Properties"]Get the description of a model:
\!\(\*GraphicsBox[«8»]\)["Description"]Change the description of the model:
model2 = SystemModel[\!\(\*GraphicsBox[«8»]\), <|"Description" -> "Motor model"|>];model2["Description"]Get the diagram of a model as a Graphics:
[image]["Diagram"]Get the system equations of a model:
[image]["SystemEquations"]Get the components and connections in a DC motor model:
model = [image];model["Components"]model["Connections"]Model Representations (7)
Get the diagram of a model as a Graphics:
[image]["Diagram"][image][{"Diagram", GridLines -> Inherited}][image][{"Diagram", FrameTicks -> True}]Get the diagram of a component in a model:
[image]["Diagram", "motor"]Increase the PlotRangePadding for a diagram:
[image][{"Diagram", PlotRangePadding -> 20}]Show the diagram of a model without a frame, using the page size from the model:
model = [image];model[{"Diagram", Frame -> False, PlotRange -> Inherited}]\!\(\*GraphicsBox[«8»]\)["ModelicaIcon"]Show the text view of a model:
[image]["ModelicaDisplay"]
Retrieve the Modelica code of a model as a String:
[image]["ModelicaString"]//ShortModel Information (5)
Get the path of the file containing a model:
[image]["SourceFile"]Retrieve the model name of a SystemModel:
[image]["ModelName"]model2 = SystemModel[[image], <|"ModelName" -> "MyMotor"|>];model2["ModelName"]Get a link to the documentation for a model:
[image]["DocumentationURL"][image]["Documentation"]model1 = SystemModel["IntroductoryExamples.ComponentBased.ElectricCircuit"]Retrieve the simulation settings of a model:
model1["SimulationSettings"]From this model, create one with new simulation settings:
model2 = SystemModel[model1, <|"SimulationSettings" -> {"StopTime" -> 5}|>]Retrieve the simulation settings of the new model:
model2["SimulationSettings"]Get the domain usage in a model:
[image]["Domain"]Get a chart of the domains used in a model:
[image]["DomainChart"]Variables and Equations (9)
Get the system equations of a model:
[image]["SystemEquations"]Get the initial equations of a model:
[image]["InitialEquations"]Get all state variables of a model:
[image]["StateVariables"]Get a list of all algebraic variables in the model:
[image]["AlgebraicVariables"]//ShortGet a list of all system variables in the model:
[image]["SystemVariables"]//ShortGet a list of all input variables in the model:
[image]["InputVariables"]Get a list of all output variables in the model:
[image]["OutputVariables"]Get the discrete variables of a model:
[image]["DiscreteVariables"]Get all parameter names of a model:
[image]["ParameterNames"]Retrieving Initial and Parameter Values (3)
Modifying Initial and Parameter Values (5)
Change the value of the parameter a from 3 to 10:
model = [image];model["ParameterValues"]model2 = SystemModel[model, <|"ParameterValues" -> {"a" -> 10}|>]model2["ParameterValues"]Set the start value of the variable x to 3:
model = [image];model2 = SystemModel[model, <|"InitialValues" -> {"x" -> 3}|>];model2["InitialValues"]Use a model with a multidimensional variable:
model = [image];model["ModelicaDisplay"]
Set the initial values for the variable:
model2 = SystemModel[model, <|"InitialValues" -> {"x" -> {{1, 2, 3}, {4, 5, 6}}}|>]The start value of the variable x is updated:
model2["ModelicaDisplay"]
model = SystemModel["DocumentationExamples.Basic.SetValuesString"];model["ParameterValues"]Give the string parameter a new value:
model2 = SystemModel[model, <|"ParameterValues" -> {"x" -> "newXValue"}|>]model2["ParameterValues"]In many cases, parameters and initial values can be set without being explicit:
model = [image];model["InitialValues"]model["ParameterValues"]Set the parameter a and the initial value for variable y without specifying which is a parameter:
model2 = SystemModel[model, <|"a" -> 5, "y" -> 14|>]The start value for variable y was modified:
model2["InitialValues"]The value for the parameter a was modified:
model2["ParameterValues"]Time Variable and Filtering (2)
By default, equations use t as the time variable:
model = [image];model["SystemEquations"]Get the differential equations depending on a chosen variable:
model["SystemEquations", τ]Get parameter values matching a pattern:
[image][{"ParameterValues", "*.startTime"}]Structural Properties (5)
Get the models a model builds on:
base = [image]["ExtendsModels"]Comap[base, "ModelName"]model1 = SystemModel["IntroductoryExamples.ComponentBased.ElectricCircuit"]From a model, create a new one that extends another class:
model2 = SystemModel[model1 , <|"ExtendsModels" -> "IntroductoryExamples.ComponentBased.ElectricCircuit2"|>]Confirm the list of extended models:
model2["ExtendsModels"]Get the components and connections in a DC motor model:
model = [image];model["Components"]model["Connections"]Get the components locally declared in a model:
model = [image];model["LocalComponents"]Get components inherited from "ExtendsModels":
model["InheritedComponents"]"Components" includes both local and inherited components:
model["Components"]Get the connectors in a model:
[image]["Connectors"]Model Relations (3)
Show the hierarchical relations of a model:
model = SystemModel["IntroductoryExamples.MultiDomain"];parent = model["Parent"]parent["ModelName"]children = model["Children"]Comap[children, "ModelName"]siblings = model["Siblings"]Comap[siblings, "ModelName"]Find all models that use a resistor as a component:
resistor = SystemModel["Modelica.Electrical.Analog.Basic.Resistor"];resistor["ModelsContaining"]//ShallowFind all models that build upon an electrical one-port:
oneport = SystemModel["Modelica.Electrical.Analog.Interfaces.OnePort"];oneport["ModelsExtending"]//ShallowRetrieving Model Plots (3)
Get the names of plots in the model:
model = [image];plotNames = model["PlotNames"]Simulate and show a model plot:
SystemModelPlot[model, First[plotNames]]Get the full specifications of the plots in the model:
model = [image];plotspec = model["Plots"]The same format can be used to set plots in models. Make a copy of the model without plots:
model2 = SystemModel[model, <|"Plots" -> {}|>];model2["Plots"]model2 = SetSystemModel[model2, <|"Plots" -> plotspec|>];SystemModelPlot[model2, "Trajectory"]model = [image];model["PlotNames"]There are no plots saved locally in the model:
model["LocalPlotNames"]The plot comes from the extended model:
{extendedModel} = model["ExtendsModels"]extendedModel["LocalPlotNames"]Modifying Model Plots (12)
Define a parametric plot in a model:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "x vs y", "Subplots" -> {<|"Variables" -> {{"x", "y"}}|>}|>}|>]Simulate and show the newly defined plot:
SystemModelPlot[model, "x vs y", 15, PlotRange -> All]Define a plot with sensitivity of "integrator1.y" to parameter "sine.f" varying by 10%:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "FrequencySensitivity", "Subplots" -> {<|"Variables" -> {{"integrator1.y", "sine.f", 0.1}}|>}|>}|>]Simulate with sensitivity analysis against the frequency parameter:
sim = SystemModelSimulateSensitivity[model, 1, {"sine.f"}]SystemModelPlot[sim, "FrequencySensitivity"]model = SystemModel[[image], <|"Plots" -> {<|"Group" -> "MyGroup", "Name" -> "Plot1", "Subplots" -> {<|"Variables" -> {"y"}|>}|>, <|"Group" -> "MyGroup", "Name" -> "Plot2", "Subplots" -> {<|"Variables" -> {"z"}|>}|>}|>];Simulate and show all plots in the group:
SystemModelPlot[model, "MyGroup", 10]Define a plot with custom plot legends:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "CustomLegends", "Subplots" -> {<|"Variables" -> {"y", "z"}, "PlotLegends" -> {"Rollercoaster", "Wave"}|>}|>}|>];SystemModelPlot[model, "CustomLegends", 10]Define a plot with custom axis labels:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "CustomAxis", "Subplots" -> {<|"Variables" -> {"y", "z"}, "AxesLabel" -> {"Over Time", "Up And Down"}|>}|>}|>];SystemModelPlot[model, "CustomAxis", 10]Define a plot with a restricted plot range:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "CustomPlotRange", "Subplots" -> {<|"Variables" -> {"y", "z"}, "PlotRange" -> {-0.7, 0.7}|>}|>}|>];SystemModelPlot[model, "CustomPlotRange", 10]Define a plot with a constrained time range:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "ConstrainX", "Subplots" -> {<|"Variables" -> {"y", "z"}, "Interval" -> {2, 4}|>}|>}|>];SystemModelPlot[model, "ConstrainX", 10]Define a plot without axes labels:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "NoAxesLabels", "Subplots" -> {<|"Variables" -> {"y", "z"}, "AxesLabel" -> None|>}|>}|>];SystemModelPlot[model, "NoAxesLabels", 10]Define a plot with an axis label for one axis:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "OneAxesLabel", "Subplots" -> {<|"Variables" -> {"y", "z"}, "AxesLabel" -> {None, "WaveHeight"}|>}|>}|>];SystemModelPlot[model, "OneAxesLabel", 10]model = SystemModel[[image], <|"Plots" -> {<|"Default" -> True, "Subplots" -> {<|"Variables" -> {"y", "z"}|>}|>}|>];Default plots are used in SystemModelPlot if no plot name or variables are given:
SystemModelPlot[model, 10]Giving the same name as an existing plot overwrites the plot:
model = SystemModel[[image], <|"Plots" -> {<|"Name" -> "PlotName", "Subplots" -> {<|"Variables" -> {"y"}|>}|>}|>];model2 = SystemModel[model, <|"Plots" -> {<|"Name" -> "PlotName", "Subplots" -> {<|"Variables" -> {"z"}|>}|>}|>];The plot defined last is used:
SystemModelPlot[model2, "PlotName", 10]model = [image];plotNames = model["PlotNames"]Remove one of the plots from the model by giving an empty subplot list:
model2 = SystemModel[model, <|"Plots" -> {<|"Name" -> First[plotNames], "Subplots" -> {}|>}|>];model2["PlotNames"]Options (5)
Method (4)
Use a custom start time in initial equations:
[image]["InitialEquations", Method -> {"StartTime" -> 5}]Use a custom start time in initial seedings:
[image]["InitialSeedings", Method -> {"StartTime" -> 5}]The Method option "Elimination" can be used to eliminate redundant equations:
model = \!\(\*GraphicsBox[«8»]\);model["SystemEquations", Method -> {"Elimination" -> All}]//LengthElimination can greatly reduce the number of equations:
model["SystemEquations", Method -> {"Elimination" -> None}]//LengthDisable index reduction with the method option "ReduceIndex":
\!\(\*GraphicsBox[«8»]\)["SystemEquations", Method -> {"ReduceIndex" -> False}]//ShortExtract model properties with variables as QuantityVariable:
model = \!\(\*GraphicsBox[«8»]\);model["SystemVariables", Method -> {"VariableFormat" -> QuantityVariable}]//ShortExtract model properties with variables as String:
model["SystemVariables", Method -> {"VariableFormat" -> String}]//ShortProgressReporting (1)
Control progress reporting with ProgressReporting:
SystemModel[[image], "StateVariables", ProgressReporting -> False]Applications (6)
Solve equations using NDSolve:
model = [image];eqs = model["SystemEquations"];Construct initial equations from an initial values list:
initeqs = Map[#[[1]][0] == #[[2]]&, model["InitialValues"]];var = First[model["SystemVariables"]]s = NDSolve[Join[eqs, initeqs], var, {, 0, 10}]Plot[Evaluate[var[t] /. s], {t, 0, 10}]Solve equations using DSolve:
model = [image];Get the equations and system variables:
eqs = model["SystemEquations"]vars = model["SystemVariables"]initeqs = Map[#[0] == (# /. model["InitialValues"])&, vars]Combine the equations and replace all parameters with their default values:
alleqs = Join[eqs, initeqs] /. model["ParameterValues"]Solve the system and plot the result:
s = DSolve[alleqs, vars, ]Plot[Evaluate[Comap[vars, t] /. s], {t, 0, 10}]Find an equilibrium point for a model:
model = [image];eqs = model["SystemEquations", t]vars = model["SystemVariables"]Set derivatives to zero and solve:
Solve[eqs /. Derivative[1][_][t] -> 0, Comap[vars, t]]FindSystemModelEquilibrium gives the same result:
FindSystemModelEquilibrium[model]Use the differential equations to study the behavior of a damped pendulum:
model = [image];eqns = model["SystemEquations"]sol[initx1_, initx2_] := NDSolve[Join[eqns, {x1[0] == initx1, x2[0] == initx2}], {x1[], x2[]}, {, 0, 10}][[1, All, 2]]Manipulate[Show[Table[ParametricPlot[Evaluate@sol[i, j], {, 0, 10}, PlotRange -> {{-7, 7}, {-7, 7}}], {i, -5, 5, 0.1}]], {{j, 0}, -2, 2, 0.5}, SaveDefinitions -> True, SynchronousUpdating -> False, SynchronousInitialization -> False]Transfer a StateSpaceModel of a mass-spring-damper system into a SystemModeler model:
ss = StateSpaceModel[{m x''[t] + q x'[t] + k x[t] == f[t]}, {{x[t], 0}, {x'[t], 0}}, {{f[t], 0}}, {x[t]}, t];{a, b, c, d} = Normal[ss] /. {m -> 1, k -> 0.1, q -> 0.1};model2 = SystemModel["DocumentationExamples.Basic.SetValuesStateSpace", {"ss.A" -> a, "ss.B" -> b, "ss.C" -> c, "ss.D" -> d}]sim = SystemModelSimulate[model2, {0, 50}, <|"Inputs" -> {"u" -> Sin}|>];SystemModelPlot[sim, {"y"}]Transfer a mass-spring-damper TransferFunctionModel into a model:
With[{m = 1, k = 1.5, b = 0.1}, tf = TransferFunctionModel[ (1/m s^2 + b s + k), s]]Get coefficients for denominator and numerator:
{a, b} = {Denominator[tf[s][[1, 1]]], Numerator[tf[s][[1, 1]]]};{ca, cb} = {CoefficientList[a, s], CoefficientList[b, s]}Set coefficients in the model:
model = SystemModel["DocumentationExamples.Basic.SetValuesTransferFunction", {"tf.a" -> ca, "tf.b" -> cb}]sim = SystemModelSimulate[model, {0, 50}, <|"Inputs" -> {"u" -> Sin}|>];SystemModelPlot[sim, {"y"}]Properties & Relations (9)
A model is represented by a graphical representation:
SystemModel["IntroductoryExamples.MultiDomain.DCMotor"]The representation can be used as input to other functions:
SystemModelSimulate[[image]]The full name of the model as a string can be retrieved with a property:
[image]["ModelName"]The string of the model name can be used in place of the full SystemModel expression:
SystemModelSimulate["IntroductoryExamples.MultiDomain.DCMotor"]A shortened version of the name can be used to refer to a model if it is unique:
model = SystemModel["NewtonCradle"]The resulting object will refer to the fully qualified model name:
model["ModelName"]Non-unique shortened names will give a message and not give a typeset object:
SystemModel["Resistor"]
A diagram of a component may be different than a diagram of the component model:
SystemModel["DocumentationExamples.Modeling.ModifiedPendulum"]["Diagram", "motor"]The motor model itself does not have parameters set:
SystemModel["IntroductoryExamples.Systems.Components.ElectricalMotor"]["Diagram"]SystemModel generates a new model with applied changes:
model = [image];model["ParameterValues"]The old and new models are two different objects:
model2 = SystemModel[model, <|"ParameterValues" -> {"a" -> 10}|>];{model["ParameterValues"], model2["ParameterValues"]}SetSystemModel makes changes in place, modifying the given object:
SetSystemModel[model2, <|"ParameterValues" -> {"a" -> 14}|>];model2["ParameterValues"]Import loads a model from disk using the "MO" format:
Import["ExampleData/ExampleModel.mo", "MO"]After importing, the model can be accessed using SystemModel:
SystemModel["ExampleModel"]["Summary"]Use DeleteObject to delete a model:
model = CreateSystemModel[{u[t] == u'[t]}, t]DeleteObject[model]Trying to use a deleted model will give an error:
model["SystemEquations"]
Export saves a model to disk:
model = CreateSystemModel[{u[t] == u'[t]}, t];Save the newly model as "DiffEq":
Export[FileNameJoin[{$TemporaryDirectory, "DiffEq.mo"}], model, "MO"];FilePrint[SystemModel["DiffEq"]["SourceFile"]]
Clean up by deleting the new file and model:
DeleteFile[SystemModel["DiffEq"]["SourceFile"]];
DeleteObject[{SystemModel["DiffEq"], model}];System models can be explored using entities:
Entity["SystemModel", "IntroductoryExamples"]List the available properties:
EntityProperties["SystemModel"]//ShallowList the children of a system model:
Entity["SystemModel", "IntroductoryExamples"][EntityProperty["SystemModel", "Children"]]Retrieve the system equations of a model:
Entity["SystemModel", "IntroductoryExamples.HelloWorld"]["SystemEquations"]Compare the solutions from SystemModelSimulate and NDSolve:
model = [image];eqs = model["SystemEquations"];vars = model["SystemVariables"];initvals = model["InitialValues"];initeqs = Map[#[[1]][0] == #[[2]]&, initvals];Solve using NDSolve:
ndsol = NDSolve[Join[eqs, initeqs], vars, {, 0, 10}][[1, 1, 2]];Solve using SystemModelSimulate:
sim = SystemModelSimulate[model, {0, 10}];simsol = sim[{"x"}, ][[1]];Table[Abs[ndsol[] - simsol], {, 0, 10}]//MaxRelated Links
Wolfram System Modeler DocumentationText
Wolfram Research (2018), SystemModel, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemModel.html (updated 2020).
CMS
Wolfram Language. 2018. "SystemModel." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2020. https://reference.wolfram.com/language/ref/SystemModel.html.
APA
Wolfram Language. (2018). SystemModel. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/SystemModel.html