({{, (RefLink[SystemModel, paclet:ref/SystemModel])["model"]
gives a representation of the model "model", usable as input to other functions.}, {, (RefLink[SystemModel, paclet:ref/SystemModel])["model"]["property"] 
gives the specified "property" for the model "model".}})

OpenersNotesSection(Spacer1)Details and Options

(RefLink[SystemModel, paclet:ref/SystemModel])[…]["property"] is equivalent to (RefLink[SystemModel, paclet:ref/SystemModel])[…, "property"].

(RefLink[SystemModel, paclet:ref/SystemModel])["model"]["Properties"] gives a list of possible properties.

A shortened name "model" can be used if (RefLink[SystemModels, paclet:ref/SystemModels])["*.model"] gives a unique match.

(RefLink[SystemModel, paclet:ref/SystemModel])[model,<|"property"->…|>] creates a new (RefLink[SystemModel, paclet:ref/SystemModel]) by modifying property of model.

Properties related to the whole model: »

"ModelicaDisplay" creates a cell with style "Program" containing the textual form of "model".

"ModelicaString" returns the textual form of "model" as a string.

(RefLink[SystemModel, paclet:ref/SystemModel])["model"]["Diagram","c1","c2",…] shows the diagram for component "c1.c2...ci" in "model".

(RefLink[SystemModel, paclet:ref/SystemModel])["model",{property,options}] accepts the following options for property "Diagram" and "ModelicaIcon":

(RefLink[GridLines, paclet:ref/GridLines])->(RefLink[Inherited, paclet:ref/Inherited])  inherits the grid defined in the model diagram. »

(RefLink[PlotRange, paclet:ref/PlotRange])->(RefLink[Automatic, paclet:ref/Automatic]) specifies a plot range that encloses the primitives drawn in the diagram.

(RefLink[PlotRange, paclet:ref/PlotRange])->(RefLink[Inherited, paclet:ref/Inherited])  inherits the page size specified in the model diagram. »

Properties related to stored plots:

Stored plots from "Plots" and "LocalPlots" are a list of plotspec.

Each plotspec is an (RefLink[Association, paclet:ref/Association]) with the following keys:

Stored plot "Variables" can take the following forms:

Stored plot "Interval" can be given as {(Subscript[t, min]),(Subscript[t, max])} or (Subscript[t, max]).

Stored plot "AxesLabel" can be (RefLink[Automatic, paclet:ref/Automatic]), (RefLink[None, paclet:ref/None]), a string label for the y axis or {"xlabel","ylabel"}.

Possible "PlotLegends" are (RefLink[Automatic, paclet:ref/Automatic]), (RefLink[None, paclet:ref/None]) or a list of one string per variable in the plot.

"PlotRange" is (RefLink[Automatic, paclet:ref/Automatic]), {(Subscript[y, min]),(Subscript[y, max])} or y, which is interpreted as {-y,y}.

If "Preferred" is (RefLink[True, paclet:ref/True]), the plot will be included in (RefLink[SystemModelPlot, paclet:ref/SystemModelPlot])[model].

A list of associations in plotspec creates multiple subplots in the stored plot. Common elements are taken from the first subplot.

Properties related to equations and variables: »

"SystemEquations" gives equations depending on \[FormalT].

(RefLink[SystemModel, paclet:ref/SystemModel])["model"]["SystemEquations",t] gives equations depending on t.

(RefLink[SystemModel, paclet:ref/SystemModel])[…] contains (RefLink[Missing, paclet:ref/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 (RefLink[DiscreteVariables, paclet:ref/DiscreteVariables]) option to (RefLink[NDSolve, paclet:ref/NDSolve]).

Properties related to values: »

For variable and parameter lists, (RefLink[SystemModel, paclet:ref/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:

Properties related to relations with other models:

The following options can be given:

Possible settings for "(Subscript[opt, i])" in (RefLink[Method, paclet:ref/Method])->{"(Subscript[opt, 1])"->(Subscript[val, 1])} include:

The properties "PropertyAssociation" and "PropertyDataset" return computable forms of all properties.

OpenersPrimaryExamplesSection(Spacer1)Examples  (78)

OpenersExampleSection0(Spacer1)Basic Examples  (4)

Get the representation of a model:

SystemModel["IntroductoryExamples.MultiDomain.DCMotor"]

Retrieve a property using the model representation:

["Description"]

Show a summary of a model:

["Summary"]

Get the differential equations for a model:

["SystemEquations"]

Pick a random included example model using (RefLink[SystemModelExamples, paclet:ref/SystemModelExamples]):

model=RandomChoice[SystemModelExamples["Models"]]

Show the full model name and description for the model:

model["ModelName"]

model["Description"]

OpenersExampleSection1(Spacer1)Scope  (57)

OpenersExampleSubsubsection0(Spacer1)Basic Uses  (5)

Show a list of possible properties:

["Properties"]

Get the description of a model:

["Description"]

Change the description of the model:

model2=SystemModel[,<|"Description"->"Motor model"|>];

model2["Description"]

Get the diagram of a model as a (RefLink[Graphics, paclet:ref/Graphics]):

["Diagram"]

Get the system equations of a model:

["SystemEquations"]

Get the components and connections in a DC motor model:

model=;

model["Components"]

model["Connections"]

OpenersExampleSubsubsection1(Spacer1)Model Representations  (7)

Get the diagram of a model as a (RefLink[Graphics, paclet:ref/Graphics]):

["Diagram"]

Show the grid:

[{"Diagram",GridLines->Inherited}]

Show frame ticks:

[{"Diagram",FrameTicks->True}]

Get the diagram of a component in a model:

["Diagram","motor"]

Increase the (RefLink[PlotRangePadding, paclet:ref/PlotRangePadding]) for a diagram:

[{"Diagram",PlotRangePadding->20}]

Show the diagram of a model without a frame, using the page size from the model:

[{"Diagram",Frame->False,PlotRange->Inherited}]

Show the icon of a model:

["ModelicaIcon"]

Show the text view of a model:

["ModelicaDisplay"]

({{model HelloWorld "A simple model with a differential equation"}, {  Real x(start = 1);}, {equation}, {  der(x) = -x;}, {end HelloWorld;}})

Retrieve the Modelica code of a model as a (RefLink[String, paclet:ref/String]):

["ModelicaString"]//Short

OpenersExampleSubsubsection2(Spacer1)Model Information  (4)

Get the path of the file containing a model:

["SourceFile"]

Retrieve the model name of a (RefLink[SystemModel, paclet:ref/SystemModel]):

["ModelName"]

Make a copy with a new name:

model2=SystemModel[,<|"ModelName"->"MyMotor"|>];

model2["ModelName"]

Get a link to the documentation for a model:

["Documentation"]

Get a link to the online documentation for a model in a library:

["OnlineDocumentation"]

Get the domain usage in a model:

["Domain"]

Get a chart of the domains used in a model:

["DomainChart"]

OpenersExampleSubsubsection3(Spacer1)Variables and Equations  (9)

Get the system equations of a model:

["SystemEquations"]

Get the initial equations of a model:

["InitialEquations"]

Get all state variables of a model:

["StateVariables"]

Get a list of all algebraic variables in the model:

["AlgebraicVariables"]//Short

Get a list of all system variables in the model:

["SystemVariables"]//Short

Get a list of all input variables in the model:

["InputVariables"]

Get a list of all output variables in the model:

["OutputVariables"]

Get the discrete variables of a model:

["DiscreteVariables"]

Get all parameter names of a model:

["ParameterNames"]

OpenersExampleSubsubsection4(Spacer1)Retrieving Initial and Parameter Values  (3)

Get all parameter values of a model:

["ParameterValues"]//Short

Get all initial values of a model:

["InitialValues"]//Short

Get initial values grouped by state, input and output:

["GroupedInitialValues"]

OpenersExampleSubsubsection5(Spacer1)Modifying Initial and Parameter Values  (5)

Change the value of the parameter a from 3 to 10:

model=;

model["ParameterValues"]

model2=SystemModel[model,<|"ParameterValues"->{"a"->10}|>]

model2["ParameterValues"]

Set the start value of the variable x to 3:

model=;

model2=SystemModel[model,<|"InitialValues"->{"x"->3}|>];

model2["InitialValues"]

Use a model with a multidimensional variable:

model=;

model["ModelicaDisplay"]

({{model SetValuesArrayParam}, {  extends DocumentationExamples.Icons.Textual;}, {  Real x[2, 3];}, {equation}, {  der(x) = -x;}, {end SetValuesArrayParam;}})

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 Wfab64124b4584479869e18e07de48768}, {  extends DocumentationExamples.Icons.Textual;}, {  Real x[2, 3](start = {{1, 2, 3}, {4, 5, 6}});}, {equation}, {  der(x) = -x;}, {end Wfab64124b4584479869e18e07de48768;}})

Set string values in a model:

model=SystemModel["DocumentationExamples.Basic.SetValuesString"];

model["ParameterValues"]

Give the string parameter a new value:

model2=SystemModel[model,<|"ParameterValues"->{"x"->"newXValue"}|>]

The value of x is updated:

model2["ParameterValues"]

In many cases, parameters and initial values can be set without being explicit:

model=;

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"]

OpenersExampleSubsubsection6(Spacer1)Time Variable and Filtering  (2)

By default, equations use \[FormalT] as the time variable:

model=;

model["SystemEquations"]

Get the differential equations depending on a chosen variable:

model["SystemEquations",τ]

Get parameter values matching a pattern:

[{"ParameterValues","*.startTime"}]

OpenersExampleSubsubsection7(Spacer1)Structural Properties  (4)

Get the models a model builds on:

base=["ExtendsModels"]

Show the model names:

Through[base["ModelName"]]

Get the components and connections in a DC motor model:

model=;

model["Components"]

model["Connections"]

Get the components locally declared in a model:

model=;

model["LocalComponents"]

Get components inherited from "ExtendsModels":

model["InheritedComponents"]

"Components" includes both local and inherited components:

model["Components"]

Get the connectors in a model:

["Connectors"]

OpenersExampleSubsubsection8(Spacer1)Model Relations  (3)

Show the hierarchical relations of a model:

model=SystemModel["IntroductoryExamples.MultiDomain"];

Show the parent:

parent=model["Parent"]

parent["ModelName"]

Show the children:

children=model["Children"]

Show the children's names:

Through[children["ModelName"]]

Show the siblings:

siblings=model["Siblings"]

Show the siblings' names:

Through[siblings["ModelName"]]

Find all models that use a resistor as a component:

resistor=SystemModel["Modelica.Electrical.Analog.Basic.Resistor"];

resistor["ModelsContaining"]//Shallow

Find all models that build upon an electrical one-port:

oneport=SystemModel["Modelica.Electrical.Analog.Interfaces.OnePort"];

oneport["ModelsExtending"]//Shallow

OpenersExampleSubsubsection9(Spacer1)Retrieving Stored Plots  (3)

Get the names of stored plots in the model:

model=;

model["PlotNames"]

Simulate and show the stored plot:

SystemModelPlot[model,"InertiaComparison"]

Get the full specifications of the stored plots in the model:

model=;

plotspec=model["Plots"]

The same format can be used to set plots in the model:

model2=SystemModel[model,<|"Plots"->plotspec|>];

Simulate and show the stored plot:

SystemModelPlot[model2,"InertiaComparison"]

Plots are inherited:

model=;

model["PlotNames"]

There are no plots saved locally in the model:

model["LocalPlotNames"]

The saved plot comes from the extended model:

{extendedModel}=model["ExtendsModels"]

extendedModel["LocalPlotNames"]

OpenersExampleSubsubsection10(Spacer1)Modifying Stored Plots  (12)

Store a parametric plot:

model=SystemModel[,"Plots"->{<|"Name"->"x vs y","Variables"->{{"x","y"}}|>}]

Simulate and show the newly defined plot:

SystemModelPlot[{model,15},"x vs y",PlotRange->All]

Store a plot with sensitivity of "integrator1.y" to parameter "sine.freqHz" varying by 10%.

model=SystemModel[,<|"Plots"->{<|"Name"->"FrequencySensitivity","Variables"->{{"integrator1.y","sine.freqHz",0.1}}|>}|>]

Simulate with sensitivity analysis against the frequency parameter:

sim=SystemModelSimulateSensitivity[model,1,{"sine.freqHz"}]

Show the stored plot:

SystemModelPlot[sim,"FrequencySensitivity"]

Store two plots in a group:

model=SystemModel[,<|"Plots"->{<|"Name"->"Plot1","Variables"->{"y"},"Group"->"MyGroup"|>,<|"Variables"->{"z"},"Group"->"MyGroup","Name"->"Plot2"|>}|>];

Simulate and show all plots in the group:

SystemModelPlot[{model,10},"MyGroup"]

Store a plot with custom plot legends:

model=SystemModel[,<|"Plots"->{<|"Name"->"CustomLegends","Variables"->{"y","z"},"PlotLegends"->{"Rollercoaster","Wave"}|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"CustomLegends"]

Store a plot with custom axis labels:

model=SystemModel[,<|"Plots"->{<|"Name"->"CustomAxis","Variables"->{"y","z"},"AxesLabel"->{"Over Time","Up And Down"}|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"CustomAxis"]

Store a plot with a restricted plot range:

model=SystemModel[,<|"Plots"->{<|"Name"->"CustomPlotRange","Variables"->{"y","z"},"PlotRange"->{-0.7,0.7}|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"CustomPlotRange"]

Store a plot with a constrained time range:

model=SystemModel[,<|"Plots"->{<|"Name"->"ConstrainX","Variables"->{"y","z"},"Interval"->{2,4}|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"ConstrainX"]

Store a plot without axes labels:

model=SystemModel[,<|"Plots"->{<|"Name"->"NoAxesLabels","Variables"->{"y","z"},"AxesLabel"->None|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"NoAxesLabels"]

Store a plot with an axis label for one axis:

model=SystemModel[,<|"Plots"->{<|"Name"->"OneAxesLabel","Variables"->{"y","z"},"AxesLabel"->{None,"WaveHeight"}|>}|>];

Simulate and show the plot:

SystemModelPlot[{model,10},"OneAxesLabel"]

Store a preferred plot:

model=SystemModel[,<|"Plots"->{<|"Variables"->{"y","z"},"Preferred"->True|>}|>];

Preferred plots are used in (RefLink[SystemModelPlot, paclet:ref/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[,\[LeftAssociation]"Plots"->{<|"Name"->"PlotName","Variables"->{"y"}|>}\[RightAssociation]];

model2=SystemModel[model,\[LeftAssociation]"Plots"->{<|"Name"->"PlotName","Variables"->{"z"}|>}\[RightAssociation]];

The last stored plot is used:

SystemModelPlot[{model2,10},"PlotName"]

Remove a stored plot from a model:

model=;

model["PlotNames"]

Remove one of the plots from the model by giving an empty variable list:

model2=SystemModel[model,<|"Plots"->{<|"Name"->"EndPosition","Variables"->{}|>}|>];

model2["PlotNames"]

OpenersExampleSection2(Spacer1)Options  (3)

OpenersExampleSubsection0(Spacer1)Method  (3)

Use a custom start time in initial equations:

["InitialEquations",Method->{"StartTime"->5}]

Use a custom start time in initial seedings:

["InitialSeedings",Method->{"StartTime"->5}]

The (RefLink[Method, paclet:ref/Method]) option "Elimination" can be used to eliminate redundant equations:

model=;

model["SystemEquations",Method->{"Elimination"->All}]//Length

Elimination can greatly reduce the number of equations:

model["SystemEquations",Method->{"Elimination"->None}]//Length

Disable index reduction with the method option "ReduceIndex":

["SystemEquations",Method->{"ReduceIndex"->False}]//Short

OpenersExampleSection3(Spacer1)Applications  (5)

Solve equations using (RefLink[NDSolve, paclet:ref/NDSolve]):

model=;

eqs=model["SystemEquations"];

Construct initial equations from an initial values list:

initeqs=Map[#[[1]][0]==#[[2]]&,model["InitialValues"]];

Solve the system:

var=First[model["SystemVariables"]]

s=NDSolve[Join[eqs,initeqs],var,{\[FormalT],0,10}]

Plot the found solution:

Plot[Evaluate[var[t]/.s],{t,0,10}]

Solve equations using (RefLink[DSolve, paclet:ref/DSolve]):

model=;

Get the equations and system variables:

eqs=model["SystemEquations"]

vars=model["SystemVariables"]

Get initial values:

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,\[FormalT]]

Plot[Evaluate[Through[vars[t]]/.s],{t,0,10}]

Use the differential equations to study the behavior of a damped pendulum:

model=;

eqns=model["SystemEquations"];

sol[initx1_,initx2_]:=NDSolve[Join[eqns,{QuantityVariable["x1",""][0]==initx1,QuantityVariable["x2",""][0]==initx2}],{QuantityVariable["x1",""][\[FormalT]],QuantityVariable["x2",""][\[FormalT]]},{\[FormalT],0,10}][[1,All,2]]

Manipulate[Show[Table[ParametricPlot[Evaluate@sol[i,j],{\[FormalT],0,10},PlotRange->{{-7,7},{-7,7}}],{i,-5,5,0.1}]],{{j,0},-2,2,0.5},TrackedSymbols:>{j},SynchronousUpdating->False,SynchronousInitialization->False]

Transfer a (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) of a mass-spring-damper system into a SystemModeler model:

ss=StateSpaceModel[{M x''[t]+C 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,C->0.1};

model2=SystemModel["DocumentationExamples.Basic.SetValuesStateSpace",{"ss.A"->a,"ss.B"->b,"ss.C"->c,"ss.D"->d}]

Simulate the changed model:

sim=SystemModelSimulate[model2,{0,50},<|"Inputs"->{"u"->Sin}|>];

SystemModelPlot[sim,{"y"}]

Transfer a mass-spring-damper (RefLink[TransferFunctionModel, paclet:ref/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}]

Simulate the changed model:

sim=SystemModelSimulate[model,{0,50},<|"Inputs"->{"u"->Sin}|>];

SystemModelPlot[sim,{"y"}]

OpenersExampleSection4(Spacer1)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[]

The full name of the model as a string can be retrieved with a property:

["ModelName"]

The string of the model name can be used in place of the full (RefLink[SystemModel, paclet:ref/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"]

(RefLink[SystemModel, paclet:ref/SystemModel]) generates a new model with applied changes:

model=;

model["ParameterValues"]

The old and new models are two different objects:

model2=SystemModel[model,<|"ParameterValues"->{"a"->10}|>];

{model["ParameterValues"],model2["ParameterValues"]}

(RefLink[SetSystemModel, paclet:ref/SetSystemModel]) makes changes in place, modifying the given object:

SetSystemModel[model2,<|"ParameterValues"->{"a"->14}|>];

model2["ParameterValues"]

(RefLink[Import, paclet:ref/Import]) loads a model from disk using the (StringTypeLink["MO", paclet:ref/format/MO]) format:

Import["ExampleData/ExampleModel.mo","MO"]

After importing, the model can be accessed using (RefLink[SystemModel, paclet:ref/SystemModel]):

SystemModel["ExampleModel"]["Summary"]

Use (RefLink[DeleteObject, paclet:ref/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"]

(RefLink[Export, paclet:ref/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"];

Show the saved file:

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"]//Shallow

List the children of a system model:

(Entity["IntroductoryExamples", Entity["SystemModel","IntroductoryExamples"], "Entity[\"SystemModel\", \"IntroductoryExamples\"]", "SystemModel"])[(EntityProperty["Children", EntityProperty["SystemModel","Children"], "EntityProperty[\"SystemModel\", \"Children\"]"])]

Retrieve the system equations of a model:

(Entity["IntroductoryExamples.HelloWorld", Entity["SystemModel","IntroductoryExamples.HelloWorld"], "Entity[\"SystemModel\", \"IntroductoryExamples.HelloWorld\"]", "SystemModel"])["SystemEquations"]

Compare the solutions from (RefLink[SystemModelSimulate, paclet:ref/SystemModelSimulate]) and (RefLink[NDSolve, paclet:ref/NDSolve]):

model=;

eqs=model["SystemEquations"];

vars=model["SystemVariables"];

initvals=model["InitialValues"];

initeqs=Map[#[[1]][0]==#[[2]]&,initvals];

Solve using (RefLink[NDSolve, paclet:ref/NDSolve]):

ndsol=NDSolve[Join[eqs,initeqs],vars,{\[FormalT],0,10}][[1,1,2]];

Solve using (RefLink[SystemModelSimulate, paclet:ref/SystemModelSimulate]):

sim=SystemModelSimulate[model,{0,10}];

simsol=sim[{"x"},\[FormalT]][[1]];

Table[Abs[ndsol[\[FormalT]]-simsol],{\[FormalT],0,10}]//Max

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[SystemModels, paclet:ref/SystemModels])  ▪  (RefLink[SystemModelSimulate, paclet:ref/SystemModelSimulate])  ▪  (RefLink[SystemModelExamples, paclet:ref/SystemModelExamples])  ▪  (RefLink[NBodySimulation, paclet:ref/NBodySimulation])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Engineering Data, paclet:guide/EngineeringData])}, {▪(RefLinkPlain[System Model Creation, paclet:guide/SystemModelCreation])}, {▪(RefLinkPlain[System Model Analytics & Design, paclet:guide/SystemModelAnalyticsDesign])}, {▪(RefLinkPlain[Life Sciences & Medicine: Data & Computation, paclet:guide/LifeSciencesAndMedicineDataAndComputation])}, {▪(RefLinkPlain[System Modeling Overview, paclet:guide/SystemModelingOverview])}, {▪(RefLinkPlain[Scientific Models, paclet:guide/ScientificModels])}, {▪(RefLinkPlain[Systems Modeling, paclet:guide/SystemsModeling])}, {▪(RefLinkPlain[Scientific Data Analysis, paclet:guide/ScientificDataAnalysis])}})}})

({{(Spacer1), ({{(Spacer1)Related Links}, {(Spacer1)▪(WebLink[(Spacer1)Wolfram SystemModeler Documentation, http://reference.wolfram.com/system-modeler/])}})}})