Wolfram Language & System Documentation Center

ConnectSystemModelComponents

ConnectSystemModelComponents[{"c₁"∈comp₁,…},{"c₁.a""c₂.b",…}]

creates a system model by connecting connector "a" of component "c₁" with connector "b" of component "c₂" etc.

Details and Options

ConnectSystemModelComponents assembles components to create a new system model. These connections communicate values and set conservation laws in the system.
ConnectSystemModelComponents returns SystemModel[…].
ConnectSystemModelComponents["NewModel",…] gives the created model the name "NewModel".
ConnectSystemModelComponents["PackageA.NewModel",…] inserts "NewModel" into "PackageA".
The comp_i can be a SystemModel object, a full model name string or a shortened model name accepted by SystemModel.
In ConnectSystemModelComponents[…,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

With ConnectSystemModelComponents[…,"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
The layout for the created model diagram can be controlled with the option GraphLayout.

Examples

open all close all

Basic Examples (2)

Create a simple electrical circuit:

Wolfram Language code:

components = {"L"∈"Modelica.Electrical.Analog.Basic.Inductor", "AC"∈"Modelica.Electrical.Analog.Sources.SineVoltage", "G"∈"Modelica.Electrical.Analog.Basic.Ground"};

Wolfram Language code: connections = {"G.p" -> "AC.n", "AC.p" -> "L.n", "L.p" -> "AC.n"};

Wolfram Language code: model = ConnectSystemModelComponents[components, connections]

Show the current and voltage in the inductor:

Wolfram Language code: SystemModelPlot[model, {"L.i", "L.v"}, 5]

Use short naming to refer to the Abs and Sine components in Modelica.Blocks:

Wolfram Language code: comp = {"a"∈"Math.Abs", "sine"∈"Sources.Sine"};

Wolfram Language code: conn = {"sine.y" -> "a.u"};

Wolfram Language code: model = ConnectSystemModelComponents[comp, conn]

Wolfram Language code: SystemModelPlot[model, {"a.y"}, 2]

Scope (5)

Create a block example, sampling a sine wave at regular intervals:

Wolfram Language code: comp = {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"Discrete.Sampler"};

Wolfram Language code: conn = {"sine.y""sample.u"};

Wolfram Language code: model = ConnectSystemModelComponents[comp, conn]

Simulate and plot the sampled signal:

Wolfram Language code: SystemModelPlot[model, {"sample.y"}, 2]

Give a value to a parameter in a component:

Wolfram Language code: comp = {"inAdd"∈"DocumentationExamples.Basic.InputAdd", "cSource"∈"Modelica.Blocks.Sources.Constant"};

Wolfram Language code: conn = {"cSource.y""inAdd.u"};

Set the amplitude of the sine to 3:

Wolfram Language code: model = ConnectSystemModelComponents[comp, conn, <|"ParameterValues" -> {"inAdd.sine.amplitude" -> 3}|>]

Simulate and plot the output:

Wolfram Language code: SystemModelPlot[model, {"inAdd.y"}, 2]

Connect two masses with heat capacity with a thermal conductor:

Wolfram Language code: comp = {"mass1"∈"HeatCapacitor", "mass2"∈"HeatCapacitor", "conduction"∈"ThermalConductor"};

Wolfram Language code: conn = {"mass1.port""conduction.port_a", "conduction.port_b""mass2.port"};

Wolfram Language code: model = ConnectSystemModelComponents[comp, conn]

Set heat capacities, masses and initial temperatures:

Wolfram Language code:

model2 = SystemModel[model, {"conduction.G" -> 10, "mass1.C" -> 15, "mass2.C" -> 40, "mass1.T" -> 373.15, "mass2.T" -> 273.15}];

Show that a temperature equilibrium is reached:

Wolfram Language code: SystemModelPlot[model2, {"mass1.T", "mass2.T"}, 5]

Create a mass connected to a spring:

Wolfram Language code:

comp = {"fixed"∈"Modelica.Mechanics.Translational.Components.Fixed", "spring"∈"Modelica.Mechanics.Translational.Components.Spring", "mass"∈"Modelica.Mechanics.Translational.Components.Mass"};

Wolfram Language code: conn = {"fixed.flange""spring.flange_a", "spring.flange_b""mass.flange_a"};

Move the initial position of the mass, stretching the spring:

Wolfram Language code: model = ConnectSystemModelComponents[comp, conn, <|"InitialValues" -> {"mass.s" -> 2}|>]

Show how the mass position oscillates:

Wolfram Language code: SystemModelPlot[model, {"mass.s"}, 10]

Build a damped 3D pendulum:

Wolfram Language code:

comp = {"world"∈"Modelica.Mechanics.MultiBody.World", "rev"∈"Modelica.Mechanics.MultiBody.Joints.Revolute", "damper"∈"Modelica.Mechanics.Rotational.Components.Damper", "body"∈"Modelica.Mechanics.MultiBody.Parts.Body"};

Wolfram Language code:

conn = {"world.frame_b""rev.frame_a", "damper.flange_b""rev.axis", "rev.support""damper.flange_a", "body.frame_a""rev.frame_b"};

Set parameter values:

Wolfram Language code:

model = ConnectSystemModelComponents[comp, conn, <|"ParameterValues" -> {"rev.useAxisFlange" -> True, "body.r_CM" -> {1, 0, 0}, "damper.d" -> 0.1}|>]

Simulate and animate the path of the pendulum:

Wolfram Language code: sim = SystemModelSimulate[model, 10];

Wolfram Language code: graphics = sim["Graphics3D", t];

Wolfram Language code:

pendulum[x_ ? NumberQ] := pendulum[x] = Show[graphics /. t -> x, PlotRange -> {{-1.2, 1.2}, {-1.2, 0.1}, {-.2, .2}}, ImageSize -> 300]

Wolfram Language code:

Animate[Evaluate[pendulum[x]], {x, 0, 10}, AnimationRate -> 0.5, AnimationRunning -> False, SaveDefinitions -> True, TrackedSymbols :> {pendulum, x, graphics}]

Generalizations & Extensions (1)

Rule, DirectedEdge and UndirectedEdge can be used for connections:

Wolfram Language code: comp1 = {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"ZeroOrderHold"};

Use Rule to specify a connection:

Wolfram Language code: conn1 = {"sine.y" -> "sample.u"};

Wolfram Language code: model1 = ConnectSystemModelComponents[comp1, conn1]

Use DirectedEdge and UndirectedEdge to specify connections:

Wolfram Language code: comp2 = Append[comp1, "foh"∈"FirstOrderHold"];

Wolfram Language code: conn2 = {"sine.y""sample.u", "sample.y""foh.u"};

Wolfram Language code: model2 = ConnectSystemModelComponents[comp2, conn2]

Simulate and plot the signals:

Wolfram Language code: Column[{SystemModelPlot[model1, {"sample.y"}, 2], SystemModelPlot[model2, {"foh.y"}, 2]}]

Options (3)

GraphLayout (3)

GraphLayout can be used to specify the layout of the model diagram:

Wolfram Language code: comp = {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"ZeroOrderHold", "foh"∈"FirstOrderHold"};

Wolfram Language code: conn = {"sine.y""sample.u", "sample.y""foh.u"};

Wolfram Language code: ConnectSystemModelComponents[comp, conn, GraphLayout -> "LinearEmbedding"]

An edge-weighted "SpringElectricalEmbedding" is used by default:

Wolfram Language code: comp = {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"ZeroOrderHold"};

Wolfram Language code: conn = {"sine.y" -> "sample.u"};

Wolfram Language code: ConnectSystemModelComponents[comp, conn, GraphLayout -> {"SpringElectricalEmbedding", "EdgeWeighted" -> True}]

Turn off automatic layout:

Wolfram Language code: comp = {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"ZeroOrderHold"};

Wolfram Language code: conn = {"sine.y" -> "sample.u"};

Wolfram Language code: ConnectSystemModelComponents[comp, conn, GraphLayout -> None]

Applications (3)

A DC Motor (1)

Create a model of a DC motor by connecting electrical and mechanical components:

Wolfram Language code:

components = {"step1"∈"Blocks.Sources.Step", "resistor1"∈"Analog.Basic.Resistor", "inductor1"∈"Analog.Basic.Inductor", "EMF1"∈"RotationalEMF", "ground1"∈"Analog.Basic.Ground", "signalVoltage1"∈"Analog.Sources.SignalVoltage", "inertia1"∈"Rotational.Components.Inertia"};

Wolfram Language code:

connections = {"resistor1.n""inductor1.p", "inductor1.n""EMF1.p", "step1.y""signalVoltage1.v", "signalVoltage1.p""resistor1.p", "EMF1.n""signalVoltage1.n", "ground1.p""signalVoltage1.n", "EMF1.flange""inertia1.flange_a"};

Wolfram Language code: model = ConnectSystemModelComponents[components, connections]

Show the angular velocity of the DC motor:

Wolfram Language code: SystemModelPlot[model, "inertia1.w", 10]

A Lowpass Filter (1)

Create a digital lowpass filter:

Wolfram Language code: a = LeastSquaresFilterKernel[{"Lowpass", 0.1}, 20];

Convert the filter into a transfer function:

Wolfram Language code: h = ListZTransform[a, z];

Wolfram Language code: tf = TransferFunctionModel[h, z, SamplingPeriod -> 0.01]//TransferFunctionCancel

Create a model of the filter:

Wolfram Language code: lowPass = CreateSystemModel[tf];

Create a signal generating source:

Wolfram Language code:

signal = CreateSystemModel["Signal", {y[t] == Abs[Sin[t Cos[2t]]]t}, t, <|"ExtendsModels" -> "Modelica.Blocks.Interfaces.SignalSource"|>];

Connect the signal source to the filter:

Wolfram Language code:

model = ConnectSystemModelComponents["FilteredSignal", {"signal"∈signal, "filter"∈lowPass}, {"signal.y""filter.u"}]

Simulate and plot the signal output and the filtered signal:

Wolfram Language code: sim = SystemModelSimulate[model, 10];

Wolfram Language code: SystemModelPlot[sim, {"signal.y", "filter.y"}]

An Inerter (1)

Create an inerter, with forces at the terminals proportional to relative acceleration:

Wolfram Language code:

inerter = CreateSystemModel["Inerter", {f[t] == b(Subscript[v, rel]'[t])}, t, <|"ExtendsModels" -> "Translational.Interfaces.PartialCompliantWithRelativeStates"|>];

Compare how adding an inerter to a damping system influences vibrations:

Wolfram Language code:

comp = {"damper"∈"Modelica.Mechanics.Translational.Components.Damper", "mass"∈"Modelica.Mechanics.Translational.Components.Mass", "force"∈"Modelica.Mechanics.Translational.Sources.Force", "vibration"∈"Interfaces.RealInput", "fixed"∈"Modelica.Mechanics.Translational.Components.Fixed", "spring"∈"Modelica.Mechanics.Translational.Components.Spring"};

Wolfram Language code:

conn = {"fixed.flange" -> "spring.flange_a", "fixed.flange" -> "damper.flange_a", "damper.flange_b" -> "mass.flange_a", "spring.flange_b" -> "mass.flange_a", "force.flange" -> "mass.flange_a", "vibration" -> "force.f"};

Wolfram Language code: damping = ConnectSystemModelComponents[comp, conn]

Wolfram Language code:

inerterDamping = ConnectSystemModelComponents[Append[comp, "inerter"∈inerter], Join[conn, {"inerter.flange_b" -> "mass.flange_a", "inerter.flange_a" -> "fixed.flange"}]]

Set parameter values and simulate the system with a sine vibration force:

Wolfram Language code: d = 300;

Wolfram Language code: b = 700;

Wolfram Language code: c = 275;

Wolfram Language code: m = 2000;

Wolfram Language code: vibr = Function[t, Sin[10t]];

Wolfram Language code: tstop = 50;

Wolfram Language code:

simInerter = SystemModelSimulate[inerterDamping, tstop, <|"Inputs" -> {"vibration" -> vibr}, "ParameterValues" -> {"inerter.b" -> b, "damper.d" -> d, "spring.c" -> c, "mass.m" -> m}|>];

Wolfram Language code:

simDamper = SystemModelSimulate[damping, tstop, <|"Inputs" -> {"vibration" -> vibr}, "ParameterValues" -> {"damper.d" -> d, "spring.c" -> c, "mass.m" -> m}|>];

Damping effects are of similar magnitude:

Wolfram Language code: SystemModelPlot[{simInerter, simDamper}, {"mass.s"}, PlotLegends -> {"Inerter", "No inerter"}]

Forces acting on the damper component are significantly reduced with an inerter:

Wolfram Language code: damperForceInerter = simInerter[{"damper.f"}]//First;

Wolfram Language code: damperForce = simDamper[{"damper.f"}]//First;

Wolfram Language code: Plot[{Abs[damperForceInerter[t]], Abs[damperForce[t]]}, {t, 0, 10}, PlotLegends -> {"Inerter", "No inerter"}]

Properties & Relations (3)

Use CreateSystemModel to create models based on differential equations:

Wolfram Language code:

model = CreateSystemModel[{Subscript[y, 1]'[t] == Subscript[y, 1][t] + Subscript[y, 2][t], Subscript[y, 2]'[t] == Subscript[y, 1][t] + Sin[t]}, t];

Wolfram Language code: SystemModelPlot[{model, 2.5}, {"y_1", "y_2"}]

CreateSystemModel can be used similarly to ConnectSystemModelComponents:

Wolfram Language code:

model = CreateSystemModel[{"sine.y""sample.u"}, t, {"sine"∈"Modelica.Blocks.Sources.Sine", "sample"∈"ZeroOrderHold"}];

Wolfram Language code: SystemModelPlot[{model, 2}, {"sample.y"}]

Hierarchical models based on existing components enable quick creation of larger systems:

Wolfram Language code:

components = {"controller"∈"Systems.Components.LQControlSystem", "gear"∈"Systems.Components.GearBox", "motor"∈"Systems.Components.ElectricalMotor", "pendulum"∈"Systems.Components.Pendulum"};

Wolfram Language code:

connections = {"pendulum.angle""controller.angle", "pendulum.position""controller.xPos", "motor.flange""gear.flange_a", "gear.flange_b""pendulum.flange_a", "motor.u""controller.y"};

Build a 3D inverted pendulum model with a controller:

Wolfram Language code: model = ConnectSystemModelComponents[components, connections]

A complex multidomain system can be built using few components:

Wolfram Language code: model["Summary"]

Neat Examples (1)

Show thermal conductance between vertices in a graph:

Wolfram Language code: g = HararyGraph[4, 13];

Wolfram Language code: {vlist, elist} = {VertexList[g], EdgeList[g]};

Wolfram Language code: {nv, ne} = Length /@ {vlist, elist};

Define components:

Wolfram Language code: vcomp = Map["v" <> ToString[#]∈"HeatCapacitor"&, vlist];

Wolfram Language code: ecomp = Table["e" <> ToString[i]∈"ThermalConductor", {i, ne}];

Wolfram Language code: complist = Join[vcomp, ecomp];

Define connections:

Wolfram Language code:

connlist = Join@@Table[With[{e = ToString /@ elist[[i]], is = ToString[i]}, {"v" <> e[[1]] <> ".port""e" <> is <> ".port_a", "v" <> e[[2]] <> ".port""e" <> is <> ".port_b"}], {i, ne}];

Create a model and set initial and parameter values:

Wolfram Language code: m = ConnectSystemModelComponents["ThermalGraph", complist, connlist, GraphLayout -> None];

Wolfram Language code:

SetSystemModel[m, Join[{"v1.T" -> 320}, Table["e" <> ToString[i] <> ".G" -> 10, {i, ne}], Table["v" <> ToString[i] <> ".C" -> 15, {i, nv}]]];

Simulate and animate the model, indicating temperature by color:

Wolfram Language code: sim = SystemModelSimulate[m, 5];

Wolfram Language code: temps = Table[i -> ColorData["TemperatureMap"][Rescale[sim["v" <> ToString[i] <> ".T", t], {293, 297}]], {i, nv}];

Wolfram Language code: vgraph[x_ ? NumberQ] := vgraph[x] = Graph[vlist, elist, VertexStyle -> (temps /. t -> x), VertexSize -> 0.3]

Wolfram Language code: Animate[Evaluate[vgraph[x]], {x, 0, 5}, AnimationRate -> 0.5, SaveDefinitions -> True, AnimationRunning -> False]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

ConnectSystemModelComponents

Details and Options

Examples

Basic Examples (2)

Scope (5)

Generalizations & Extensions (1)

Options (3)

GraphLayout (3)

Applications (3)

A DC Motor (1)

A Lowpass Filter (1)

An Inerter (1)

Properties & Relations (3)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

	"Method"	simulation method
	"StartTime"	simulation start time
	"StopTime"	simulation stop time

	"DASSL"	DASSL DAE solver
	"CVODES"	CVODES ODE solver

	"InterpolationPoints"	number of interpolation points
	"Tolerance"	tolerance for adaptive step size

	"Euler"	explicit Euler's method of order 1
	"Heun"	Heun's method of order 2
	"RungeKutta"	explicit Runge–Kutta method of order 4

ConnectSystemModelComponents

Details and Options

Examples

Basic Examples (2)

Scope (5)

Generalizations & Extensions (1)

Options (3)

GraphLayout (3)

Applications (3)

A DC Motor (1)

A Lowpass Filter (1)

An Inerter (1)

Properties & Relations (3)

Neat Examples (1)

See Also

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX