CreateSystemModel

CreateSystemModel[sys]

creates a Modelica SystemModel from the systems model sys.

CreateSystemModel[eqns,t]

creates a model for the system equations eqns with independent variable t.

CreateSystemModel[…,tspec]

creates a model with type specification tspec for variables and parameters.

CreateSystemModel[…,spec]

creates a model with spec for parameter values, initial values and model relations.

Details and Options

CreateSystemModel returns SystemModel[…].
CreateSystemModel["NewModel",…] gives the created model the name "NewModel".
CreateSystemModel["PackageA.NewModel"] inserts "NewModel" into "PackageA".
Possible dynamic systems models sys include StateSpaceModel, TransferFunctionModel, AffineStateSpaceModel, NonlinearStateSpaceModel and DiscreteInputOutputModel. »
Possible static systems models sys include FittedModel, NetChain and NetGraph.
Possible equations eqns include ordinary differential equations (ODE), differential algebraic equations (DAE), initial value equations and event specifications given by WhenEvent. »
Parameters in eqns and sys are taken to be variables that do not explicitly depend on t.
Type specifications tspecs for variables and parameters {tspec₁,…}, where each tspec_i has the form:
par_i∈type_i parameter type type_i

var_i∈type_i variable type type_i
The types type_i can be basic Reals, Integers and Booleans, or any Modelica type including units. »
SystemModels["Modelica.Units.*","type"] can be used to find built-in standard units.
Modelica models are typically built by combining many models into a larger system. The interaction between these models is described by the Modelica concept connector. »

A connector consists of effort, flow and stream variables. When connecting multiple connectors, flow variables are summed to 0, while effort variables are set equal.
As an example, an electrical circuit connector, commonly called a pin, consists of a voltage variable v and a current variable i.
Connecting pins n and p sums the flow variables, in this case currents i, to 0 and sets the efforts, in this case voltages v, equal:

All flow variables are positive in the direction flowing into a component.
Effort and flow variables for different domains include:

Domain	Effort Variables	Flow Variables
electrical circuits	voltage	current
magnetic circuits	magnetic potential	magnetic flux
translational mechanics	position	force
rotational mechanics	angle	torque
3D mechanics	position vector, orientation object	cut force vector, cut torque vector
fluid flow systems	pressure, specific enthalpy	mass flow rate, enthalpy flow rate
heat transfer systems	temperature	heat flow rate
block diagrams	real, integer, Boolean	-

Possible connectors conn_i for a domain are usually defined in an Interfaces package. For example, SystemModels["Modelica.Electrical.Analog.Interfaces.*","connector"] can be used to find connectors for the built-in electrical library.
The specification var_i∈conn_i can be used to specify that a variable var_i refers to a connector of type conn_i.
Variables v_i in a connector c can be referred to in eqns with c▴v_i, where the ▴ character can be entered as \[UpPointer].
The variables defined by a connector conn can be listed with SystemModel[conn,"SystemVariables"].
In CreateSystemModel[…,spec], spec is an Association with the following keys:

"ParameterValues"	{p₁val₁,…}	parameter values
"InitialValues"	{v₁val₁,…}	initial values
"ExtendsModels"	{partial₁,…}	partial models to build on
"DiscreteVariables"	{v₁,v₂,…}	variables changing only at events
"SimulationSettings"	{opt₁val₁,…}	model simulation options

Libraries often contain partial models called interfaces for building new component models. These interfaces usually consist of connectors and equations describing the basic relationships between them.

With CreateSystemModel[…,"ExtendsModels"partial], the new model is combined with the existing partial SystemModel defined in Modelica. »
A model can extend multiple models using "ExtendsModels"{"partial₁",…}.
Partial models to build on are usually defined in an Interfaces package. For example, SystemModels["Modelica.Electrical.Analog.Interfaces.*","model"|"block"] can be used to find partial models for the built-in electrical library.
"InitialValues" correspond to the start property in the Modelica model.
Allowed options in "SimulationsSettings"->{opt₁val₁,…} include:
"Method" simulation method

"StartTime" simulation start time

"StopTime" simulation stop time
Available adaptive step "Method" values include:
"DASSL" DASSL DAE solver

"CVODES" CVODES ODE solver
Options for adaptive-step methods include:
"InterpolationPoints" number of interpolation points

"Tolerance" tolerance for adaptive step size
Available fixed-step "Method" values include:
"Euler" explicit Euler's method of order 1

"Heun" Heun's method of order 2

"RungeKutta" explicit Runge–Kutta method of order 4
Options for fixed-step methods include:
"StepSize" fixed step size
With the option GeneratedAssetLocationloc, you can store generated assets in location loc.

Examples

open allclose all

Basic Examples (3)

Create a model based on a StateSpaceModel:

Create a model based on a TransferFunctionModel, giving it a custom name:

Build a model around an existing interface using equations:

Scope (50)

Systems Models (11)

Create a model of a single-input, single-output TransferFunctionModel:

Create a model of a single-input, single-output StateSpaceModel:

Multiple input, multiple output:

Create a model with parameters in a transfer-function model:

Specify parameters in a state-space model:

Define parameter values in a transfer-function model:

Give parameter values in a state-space model:

Give the types and values of parameters:

Create a model from a discrete transfer-function model:

Create a model from a discrete state-space model:

Use a descriptor system:

Create a model from an affine state-space model:

Create a model from a nonlinear state-space model:

Create a model from a discrete input-output model:

Differential Equations (12)

Create a single-equation ODE system:

Specify any order equation. Reduction of higher-order derivatives is done automatically:

Define a system of multiple equations:

Define a system with an algebraic constraint, resulting in a high-index problem:

Hybrid equations can be specified using WhenEvent:

Declare a variable a that only changes at discrete times:

Simulate and plot the model of a bouncing ball on stairs:

Wolfram Language functions are automatically translated to their Modelica equivalent:

Specify a default parameter value:

Specify a start value:

Specify types for variables and parameters:

Arrays are expressed using Indexed:

Functions used in equations are translated into functions in Modelica:

Associations and Functions (4)

An Association is converted into a record:

Use a record to store the kinematics of a particle:

Create a class with a specialization function from a Function:

Use a Module to introduce protected variables:

Regions (2)

Regions with an embedding dimension of 3 are allowed as input:

Data like RegionMeasure, RegionCentroid and MomentOfInertia are stored using "Modelica.Mechanics.MultiBody" components:

Graphics3D is not RegionQ:

DiscretizeGraphics or BoundaryDiscretizeGraphics may be able to produce a region from a Graphics3D:

Fitted Models and Neural Networks (2)

Create an input-output block from a FittedModel:

Give an input, simulate and plot:

Create an input-output block from a trained or initialized NetChain or NetGraph:

Give an input, simulate and plot:

Naming Models (3)

Give a custom name to the created model:

Show the model name:

Create a model inside a package:

Show the model name:

If no name is given, a unique name is generated:

Show the generated model name:

Give the model a custom name:

Show the new model name:

Types and Connectors (4)

Create a single output block:

Return it as a real:

Create the model:

Create a derivative block:

Define input and output connectors:

Create the model:

Create a resistor using connectors from the Electrical library:

Use the short form to refer to connectors:

Initial and Parameter Values (6)

Give a start value for a variable:

Give a start value for a parameter:

With both a start value and an initial equation, the initial equation has higher priority:

Use a parameter as an initial value:

Give a parameter value:

Give a parameter depending on another parameter:

Build on Partial Models (3)

Create a block that adds 1 to the input:

Create the block, extending a SISO block interface:

Use the short form to refer to an existing interface:

Create an enumeration from a list of pairs of strings:

Simulation Settings (3)

Give a start and a stop time to a model:

Simulate the model and plot:

Pick a Runge–Kutta method for simulation:

Show the model simulation settings:

Set real-time synchronization for a model:

Show the model simulation settings:

Options (2)

GeneratedAssetLocation (2)

Models created from regions export an asset file to $WolframDocumentsDirectory by default:

Specify a location for assets using GeneratedAssetLocation:

Models created from neural networks export an ONNX file to $WolframDocumentsDirectory by default:

Specify a location for assets using GeneratedAssetLocation:

Applications (7)

Define the equations for a bouncing ball:

Create the model:

Simulate with a restitution of 95%:

Plot the height over time:

Create a model of the Lotka–Volterra equations, modeling a predator-prey relationship:

Define initial values for the two states:

Define parameter values:

Create the model:

Show the levels of predators and prey over time:

A higher prey growth parameter speeds up the cycles in the system:

Model two connected tanks with a leak in the second tank:

Set up the equations, which include initial equations and parameters:

Create the model, using a given set of parameter values as the default:

Simulate:

Both tanks drain over time, because the second tank is leaking:

Create a mechanical translational damper with damping in only one direction:

Define the damping constant:

Create the damper using a partial interface from the Translational Mechanics library:

Compare with a bidirectional damper:

Create a digital lowpass filter:

Convert the filter into a transfer function:

Create a model of the filter:

Create a signal generating source:

Connect the signal source to the filter:

Simulate and plot the signal output and the filtered signal:

Use a region together with a world component to create a new model in which the body is affected by gravity:

Simulate and plot the position of the center of mass:

Visualize rotational phenomena for a parallelepiped:

Turn off gravity by changing a parameter in the world component and give an initial value to the angular velocity:

Simulate and obtain the rotation matrix of the frame fixed to the body:

Visualize the rotation of the body:

Properties & Relations (3)

SystemModel properties can be used to extract information from a model:

Create a new model with equations from an existing model, changing a parameter:

Simulate and compare the two models:

Special characters are translated into their long form:

Subscript is translated into _:

Possible Issues (2)

Models are not saved unless explicitly saved:

After quitting the Wolfram Language kernel, the model is gone:

CreateSystemModel supports a subset of Wolfram Language functions:

Top

CreateSystemModel

Details and Options

Examples

Basic Examples (3)