({{, (RefLink[SystemsModelParallelConnect, paclet:ref/SystemsModelParallelConnect])[(Subscript[sys, 1]),(Subscript[sys, 2])] 
connects the systems models (Subscript[sys, 1]) and (Subscript[sys, 2]) in parallel.}, {, (RefLink[SystemsModelParallelConnect, paclet:ref/SystemsModelParallelConnect])[(Subscript[sys, 1]),(Subscript[sys, 2]),{{(Subscript[in, 11]),(Subscript[in, 21])},…},{{(Subscript[out, 11]),(Subscript[out, 21])},…}]
connects the inputs (Subscript[(Subscript[in, 1]), i]) to inputs (Subscript[in, 2i]) and sums the outputs (Subscript[(Subscript[out, 1]), k]) and outputs (Subscript[(Subscript[out, 2]), k]).}})

OpenersNotesSection(Spacer1)Details

The systems model (Subscript[sys, i]) can be a (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]),  (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]), (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]), or (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]).

The inputs and outputs of the system produced by (RefLink[SystemsModelParallelConnect, paclet:ref/SystemsModelParallelConnect]) are the unions of the inputs and outputs of (Subscript[sys, 1]) and (Subscript[sys, 2]), respectively.

The arguments (Subscript[in, ij]) and (Subscript[out, ij]) are integers specifying the positions of the input or output channels.

OpenersPrimaryExamplesSection(Spacer1)Examples  (27)

OpenersExampleSection0(Spacer1)Basic Examples  (4)

Connect two continuous-time systems in parallel:

SystemsModelParallelConnect[(TransferFunctionModelFull[(1/(α s)), , , ]),(TransferFunctionModelFull[((b+s)/(a+s)), , , ])]

Connect two discrete-time systems in parallel:

SystemsModelParallelConnect[(TransferFunctionModelFull[((b+z)/(a+z)), T, , ]),(TransferFunctionModelFull[((β+z)/(α+z)), T, , ])]

Connect state-space systems:

SystemsModelParallelConnect[(StateSpaceModelFull[0, 1, 0, -(Subscript[α, 0]), -(Subscript[α, 1]), 1, (Subscript[β, 0]), (Subscript[β, 1]), 0, , , ]),(StateSpaceModelFull[0, 1, 0, 0, 0, 0, 1, 0, -(Subscript[a, 0]), -(Subscript[a, 1]), -(Subscript[a, 2]), 1, (Subscript[b, 0]), (Subscript[b, 1]), (Subscript[b, 2]), 0, , , ])]

Parallel connect a two-output, one-input system and a one-input, one-output system:

{sys1,sys2}={(TransferFunctionModelFull[((Subscript[k, 1])/(z+(Subscript[β, 1]))), ((Subscript[k, 2])/(z+(Subscript[β, 2]))), 1, , ]),(TransferFunctionModelFull[(b/(a+z)), 1, , ])};

Merge no inputs and sum no outputs:

SystemsModelParallelConnect[sys1,sys2,None,None]

Merge inputs and sum no outputs:

SystemsModelParallelConnect[sys1,sys2,All,None]

Merge no inputs and sum output 2 from sys1 with output 1 from sys2:

SystemsModelParallelConnect[sys1,sys2,None,{{2,1}}]

Merge inputs and sum output 2 from sys1 with output 1 from sys2:

SystemsModelParallelConnect[sys1,sys2,All,{{2,1}}]

OpenersExampleSection1(Spacer1)Scope  (14)

OpenersExampleSubsection0(Spacer1)Basic Uses  (7)

Connect a two-input, one-output system in parallel with a one-input, one-output system:

{(Subscript[tfm, 1]),(Subscript[tfm, 2])}={(TransferFunctionModelFull[((Subscript[a, 1])/s), ((Subscript[a, 2])/s), , , ]),(TransferFunctionModelFull[(b/s), , , ])};

Use the first input of the two-input system:

SystemsModelParallelConnect[(Subscript[tfm, 1]),(Subscript[tfm, 2]),{{1,1}},All]

Use the second input:

SystemsModelParallelConnect[(Subscript[tfm, 1]),(Subscript[tfm, 2]),{{2,1}},All]

Parallel connect a two-output system with a single-output system:

{(Subscript[tfm, 1]),(Subscript[tfm, 2])}={(TransferFunctionModelFull[((Subscript[a, 1])/s), ((Subscript[a, 2])/s), , , ]),(TransferFunctionModelFull[(b/s), , , ])};

Use the first output of the two-input system:

SystemsModelParallelConnect[(Subscript[tfm, 1]),(Subscript[tfm, 2]),All,{{1,1}}]

Use the second output:

SystemsModelParallelConnect[(Subscript[tfm, 1]),(Subscript[tfm, 2]),All,{{2,1}}]

Connect scalar systems:

SystemsModelParallelConnect[(StateSpaceModelFull[(Subscript[a, 11]), (Subscript[a, 12]), (Subscript[b, 11]), (Subscript[a, 21]), (Subscript[a, 22]), (Subscript[b, 21]), (Subscript[c, 11]), (Subscript[c, 12]), 0, , , ]),(StateSpaceModelFull[(Subscript[α, 11]), (Subscript[α, 12]), (Subscript[β, 11]), (Subscript[α, 21]), (Subscript[α, 22]), (Subscript[β, 21]), (Subscript[γ, 11]), (Subscript[γ, 12]), 0, , , ])]

Connect multivariable systems:

SystemsModelParallelConnect[(StateSpaceModelFull[(Subscript[a, 11]), (Subscript[a, 12]), (Subscript[b, 11]), (Subscript[b, 12]), (Subscript[a, 21]), (Subscript[a, 22]), (Subscript[b, 21]), (Subscript[b, 22]), (Subscript[c, 11]), (Subscript[c, 12]), 0, 0, , , ]),(StateSpaceModelFull[(Subscript[α, 11]), (Subscript[α, 12]), (Subscript[β, 11]), (Subscript[β, 12]), (Subscript[α, 21]), (Subscript[α, 22]), (Subscript[β, 21]), (Subscript[β, 22]), (Subscript[γ, 11]), (Subscript[γ, 12]), 0, 0, , , ])]

Merge the second input and sum the first output of each system:

SystemsModelParallelConnect[(StateSpaceModelFull[(Subscript[a, 11]), (Subscript[a, 12]), (Subscript[b, 11]), (Subscript[b, 12]), (Subscript[a, 21]), (Subscript[a, 22]), (Subscript[b, 21]), (Subscript[b, 22]), (Subscript[c, 11]), (Subscript[c, 12]), (Subscript[d, 11]), (Subscript[d, 12]), (Subscript[c, 21]), (Subscript[c, 22]), (Subscript[d, 21]), (Subscript[d, 22]), , , ]),(StateSpaceModelFull[(Subscript[α, 11]), (Subscript[α, 12]), (Subscript[β, 11]), (Subscript[β, 12]), (Subscript[α, 21]), (Subscript[α, 22]), (Subscript[β, 21]), (Subscript[β, 22]), (Subscript[γ, 11]), (Subscript[γ, 12]), (Subscript[D, 11]), (Subscript[D, 12]), , , ]),{{2,2}},{{1,1}}]

Connect discrete-time systems:

SystemsModelParallelConnect[(StateSpaceModelFull[(Subscript[p, 1]), 1, (Subscript[k, 1]), 0, T, , ]),(StateSpaceModelFull[(Subscript[k, 2]), T, , ])]

Connect a (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) to a (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]):

SystemsModelParallelConnect[(StateSpaceModelFull[(Subscript[a, 11]), (Subscript[a, 12]), (Subscript[b, 11]), (Subscript[a, 21]), (Subscript[a, 22]), (Subscript[b, 21]), (Subscript[c, 11]), (Subscript[c, 12]), 0, , , ]),(TransferFunctionModelFull[(k/(α+s)), , , ])]

OpenersExampleSubsection1(Spacer1)System Types  (7)

Connect two (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]) systems:

SystemsModelParallelConnect[(TransferFunctionModelFull[(a/(p+s)), , , ]),(TransferFunctionModelFull[(α/(ρ+s)), , , ])]

With delays:

SystemsModelParallelConnect[(TransferFunctionModelFull[((a (E^(-T s)))/(p+s)), , , ]),(TransferFunctionModelFull[(((E^(-τ s)) α)/(ρ+s)), , , ])]

Using improper transfer functions:

SystemsModelParallelConnect[(TransferFunctionModelFull[a+s, , , ]),(TransferFunctionModelFull[α+s, , , ])]

Connect two (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) systems:

SystemsModelParallelConnect[(StateSpaceModelFull[a, b, c, d, , , ]),(StateSpaceModelFull[α, β, γ, ρ, , , ])]

With delays:

SystemsModelParallelConnect[(StateSpaceModelFull[a+(SystemsModelDelay[(Subscript[τ, 1])]), b, c, d, , , ]),(StateSpaceModelFull[α+(SystemsModelDelay[(Subscript[τ, 2])]), β, γ, ρ, , , ])]

Using descriptor state-space models:

SystemsModelParallelConnect[(StateSpaceModelFull[e, a, b, c, d, , , ]),(StateSpaceModelFull[η, α, β, γ, ρ, , , ])]

Input linear (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]) systems:

SystemsModelParallelConnect[(AffineStateSpaceModelFull[a[(Subscript[x, 1])], b[(Subscript[x, 1])], c[(Subscript[x, 1])], d[(Subscript[x, 1])], (Subscript[x, 1]), \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]),(AffineStateSpaceModelFull[α[(Subscript[x, 2])], β[(Subscript[x, 2])], γ[(Subscript[x, 2])], ρ[(Subscript[x, 2])], (Subscript[x, 2]), \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ])]

General nonlinear (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]) systems:

SystemsModelParallelConnect[(NonlinearStateSpaceModelFull[(Subscript[f, 1])[(Subscript[x, 1]),(Subscript[u, 1])], (Subscript[h, 1])[(Subscript[x, 1]),(Subscript[u, 1])], (Subscript[x, 1]), \[Null], \[Null], {(Subscript[u, 1])}Automatic, ]),(NonlinearStateSpaceModelFull[(Subscript[f, 2])[(Subscript[x, 2]),(Subscript[u, 2])], (Subscript[h, 2])[(Subscript[x, 2]),(Subscript[u, 2])], (Subscript[x, 2]), \[Null], \[Null], {(Subscript[u, 2])}Automatic, ])]

Connecting a transfer function and state-space model will give a state-space model:

(Subscript[ss, 1])=SystemsModelParallelConnect[(TransferFunctionModelFull[((k (s+(Subscript[z, 1])))/(s+(Subscript[p, 1]))), , , ]),(StateSpaceModelFull[a, b, c, 0, , , ])]

Reversing the order gives an equivalent state-space model:

(Subscript[ss, 2])=SystemsModelParallelConnect[(StateSpaceModelFull[a, b, c, 0, , , ]),(TransferFunctionModelFull[((k (s+(Subscript[z, 1])))/(s+(Subscript[p, 1]))), , , ])]

They give the same transfer functions:

TransferFunctionModel/@ {(Subscript[ss, 1]),(Subscript[ss, 2])}//Simplify

Connection with delays:

SystemsModelParallelConnect[(TransferFunctionModelFull[(((E^(-s (Subscript[τ, 1]))) k (s+(Subscript[z, 1])))/(s+(Subscript[p, 1]))), , , ]),(StateSpaceModelFull[a+(SystemsModelDelay[(Subscript[τ, 2])]), b, c, d, , , ])]

Connecting a standard linear system and an input linear system will give an affine model:

SystemsModelParallelConnect[(TransferFunctionModelFull[((k (s+(Subscript[z, 1])))/(s+(Subscript[p, 1]))), , , ]),(AffineStateSpaceModelFull[α[x], β[x], γ[x], ρ[x], x, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ])]

SystemsModelParallelConnect[(StateSpaceModelFull[a, b, c, d, , , ]),(AffineStateSpaceModelFull[α[x], β[x], γ[x], ρ[x], x, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ])]

Connecting a standard linear or affine system with a nonlinear system gives a nonlinear model:

SystemsModelParallelConnect[(StateSpaceModelFull[a, b, c, d, , , ]),(NonlinearStateSpaceModelFull[f[x,u], h[x,u], x, \[Null], \[Null], {u}Automatic, ])]

SystemsModelParallelConnect[(AffineStateSpaceModelFull[a[x], b[x], c[x], d[x], x, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]),(NonlinearStateSpaceModelFull[f[x,u], h[x,u], x, \[Null], \[Null], {u}Automatic, ])]

TransferFunctionModel[
   {{{4 + s, 5 + s}, {-25, -25 + s}}, 25 + 4*s + s^2}, s]

OpenersExampleSection2(Spacer1)Generalizations & Extensions  (3)

Merge two systems:

tf1=(TransferFunctionModelFull[(1/s), (1/(1+s)), , , ]); tf2=(TransferFunctionModelFull[(1/(2+s)), (1/(3+s)), , , ]);

SystemsModelParallelConnect[tf1,tf2,{},{}]

Connect the corresponding inputs:

tf1=(TransferFunctionModelFull[((Subscript[a, 11])/(1+s (Subscript[b, 11]))), ((Subscript[a, 12])/(1+s (Subscript[b, 12]))), , , ]); tf2=(TransferFunctionModelFull[((Subscript[A, 11])/(1+s (Subscript[B, 11]))), ((Subscript[A, 12])/(1+s (Subscript[B, 12]))), ((Subscript[A, 21])/(1+s (Subscript[B, 21]))), ((Subscript[A, 22])/(1+s (Subscript[B, 22]))), , , ]);

SystemsModelParallelConnect[tf1,tf2,All,{}]

Sum the corresponding outputs:

{tf1,tf2}={(TransferFunctionModelFull[((Subscript[a, 11])/(1+s (Subscript[b, 11]))), ((Subscript[a, 21])/(1+s (Subscript[b, 21]))), , , ]),(TransferFunctionModelFull[((Subscript[A, 11])/(1+s (Subscript[B, 11]))), ((Subscript[A, 21])/(1+s (Subscript[B, 21]))), , , ])};

SystemsModelParallelConnect[tf1,tf2,{},All]

OpenersExampleSection4(Spacer1)Applications  (3)

A function that connects any number of matching systems in parallel:

parallel[s__]:=Fold[SystemsModelParallelConnect,First[{s}],Rest[{s}]]

Connect a family of first-order systems in parallel:

parallel@@Table[(TransferFunctionModelFull[(1/(i+s)), , , ]),{i,0,3}]

Connect several multiple-input, multiple-output systems:

{(Subscript[tfm, 1]),(Subscript[tfm, 2]),(Subscript[tfm, 3])}={(TransferFunctionModelFull[(1/s), ((1+s)/s), ((3 s)/(1+s)), (1/(1+s)), , , ]),(TransferFunctionModelFull[((4+s)/(6+s)), ((4+s)/(3+s)), (s/(6+s)), (s/(3+s)), , , ]),(TransferFunctionModelFull[((5 s)/(1+s)), 0, 0, (1/(1+s)), , , ])};
parallel[(Subscript[tfm, 1]),(Subscript[tfm, 2]),(Subscript[tfm, 3])]

Construct a parallel RLC circuit:

{resistance,inductance,capacitance}={(TransferFunctionModelFull[(1/(r s)), , , ]),(TransferFunctionModelFull[(1/(l (s^2))), , , ]),(TransferFunctionModelFull[c, , , ])};

SystemsModelParallelConnect[resistance,SystemsModelParallelConnect[inductance,capacitance]]//Simplify

Add a disturbance model to the output of a system:

{tfm,disturbanceModel}={(TransferFunctionModelFull[(s/(6+s+(s^2))), ((2.1`)/(1+s)), (4/(3.5` +2 s+(s^2))), (3/(1+s)), ((4 s)/(6+s+(s^2))), ((3+s)/(1+s)), , , ]),(TransferFunctionModelFull[((-4+s)/(13-6 s+(s^2))), , , ])};

SystemsModelParallelConnect[tfm,disturbanceModel,{},{{1,1}}]

OpenersExampleSection5(Spacer1)Properties & Relations  (3)

(RefLink[SystemsModelParallelConnect, paclet:ref/SystemsModelParallelConnect]) is essentially a summation operation:

SystemsModelParallelConnect[(TransferFunctionModelFull[(Subscript[m1, 1,1]), (Subscript[m1, 1,2]), (Subscript[m1, 1,3]), (Subscript[m1, 2,1]), (Subscript[m1, 2,2]), (Subscript[m1, 2,3]), , , ]),(TransferFunctionModelFull[(Subscript[m2, 1,1]), (Subscript[m2, 1,2]), (Subscript[m2, 1,3]), (Subscript[m2, 2,1]), (Subscript[m2, 2,2]), (Subscript[m2, 2,3]), , , ])]

(RefLink[SystemsModelParallelConnect, paclet:ref/SystemsModelParallelConnect]) is a special case of (RefLink[SystemsConnectionsModel, paclet:ref/SystemsConnectionsModel]):

{(Subscript[sys, 1]),(Subscript[sys, 2])}={(StateSpaceModelFull[(Subscript[a, 1,1]), (Subscript[a, 1,2]), (Subscript[b, 1,1]), (Subscript[b, 1,2]), (Subscript[a, 2,1]), (Subscript[a, 2,2]), (Subscript[b, 2,1]), (Subscript[b, 2,2]), (Subscript[c, 1,1]), (Subscript[c, 1,2]), 0, 0, (Subscript[c, 2,1]), (Subscript[c, 2,2]), 0, 0, , , ]),(StateSpaceModelFull[(Subscript[A, 1,1]), (Subscript[A, 1,2]), (Subscript[B, 1,1]), (Subscript[B, 1,2]), (Subscript[A, 2,1]), (Subscript[A, 2,2]), (Subscript[B, 2,1]), (Subscript[B, 2,2]), (Subscript[C, 1,1]), (Subscript[C, 1,2]), 0, 0, (Subscript[C, 2,1]), (Subscript[C, 2,2]), 0, 0, , , ])};

SystemsModelParallelConnect[(Subscript[sys, 1]),(Subscript[sys, 2])]

The common input and summer blocks:

(Subscript[com, 1])=(Subscript[com, 2])=(StateSpaceModelFull[1, 1, , , ]);

(Subscript[sum, 1])=(Subscript[sum, 2])=(StateSpaceModelFull[1, 1, , , ]);

Use (RefLink[SystemsConnectionsModel, paclet:ref/SystemsConnectionsModel]) to specify the connections:

SystemsConnectionsModel[{(Subscript[com, 1]),(Subscript[com, 2]),(Subscript[sys, 1]),(Subscript[sys, 2]),(Subscript[sum, 1]),(Subscript[sum, 2])},{{1,1}->{3,1},{1,2}->{4,1},{2,1}->{3,2},{2,2}->{4,2},{3,1}->{5,1},{3,2}-> {6,1},{4,1}-> {5,2},{4,2}->{6,2}},{{1,1},{2,1}},{{5,1},{6,1}}]

Merge the connections:

SystemsModelMerge[%]

A parallel connection leaves the states of the subsystems unchanged:

{(Subscript[ssm, 1]),(Subscript[ssm, 2])}={(StateSpaceModelFull[(Subscript[a, 1,1]), (Subscript[a, 1,2]), (Subscript[b, 1,1]), (Subscript[b, 1,2]), (Subscript[a, 2,1]), (Subscript[a, 2,2]), (Subscript[b, 2,1]), (Subscript[b, 2,2]), (Subscript[c, 1,1]), (Subscript[c, 1,2]), 0, 0, (Subscript[c, 2,1]), (Subscript[c, 2,2]), 0, 0, , (Subscript[u, 1]), (Subscript[u, 2]), (Subscript[y, 11]), (Subscript[y, 12]), (Subscript[x, 11]), (Subscript[x, 12]), , ]),(StateSpaceModelFull[(Subscript[A, 1,1]), (Subscript[A, 1,2]), (Subscript[B, 1,1]), (Subscript[B, 1,2]), (Subscript[A, 2,1]), (Subscript[A, 2,2]), (Subscript[B, 2,1]), (Subscript[B, 2,2]), (Subscript[C, 1,1]), (Subscript[C, 1,2]), 0, 0, (Subscript[C, 2,1]), (Subscript[C, 2,2]), 0, 0, , (Subscript[u, 1]), (Subscript[u, 2]), (Subscript[y, 21]), (Subscript[y, 22]), (Subscript[x, 21]), (Subscript[x, 22]), , ])};

SystemsModelParallelConnect[(Subscript[ssm, 1]),(Subscript[ssm, 2])]

The resulting system has at least as many inputs as each subsystem:

sys1=SystemsModelParallelConnect[(Subscript[ssm, 1]),(Subscript[ssm, 2]),{{1,1}},{{1,1},{2,2}}]

First[SystemsModelDimensions[sys1]]≥Max[First[SystemsModelDimensions[#]]&/@{(Subscript[ssm, 1]),(Subscript[ssm, 2])}]

A similar result holds for the minimum number of outputs:

sys2=SystemsModelParallelConnect[(Subscript[ssm, 1]),(Subscript[ssm, 2]),{{1,2},{2,1}},{{2,2}}];Last[SystemsModelDimensions[sys2]]≥Max[Last[SystemsModelDimensions[#]]&/@{(Subscript[ssm, 1]),(Subscript[ssm, 2])}]

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[SystemsModelSeriesConnect, paclet:ref/SystemsModelSeriesConnect])  ▪  (RefLink[SystemsModelFeedbackConnect, paclet:ref/SystemsModelFeedbackConnect])  ▪  (RefLink[SystemsModelStateFeedbackConnect, paclet:ref/SystemsModelStateFeedbackConnect])  ▪  (RefLink[SystemsConnectionsModel, paclet:ref/SystemsConnectionsModel])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Model Connections and Manipulations, paclet:guide/ModelConnections])}})}})