Wolfram Language & System Documentation Center

SystemsModelSeriesConnect

SystemsModelSeriesConnect[sys₁,sys₂]

connects systems models sys₁ and sys₂ in series.

SystemsModelSeriesConnect[sys₁,sys₂,{{out₁₁,in₂₁},…}]

connects outputs out_1i of sys₁ to inputs in_2i of sys₂.

Details

The systems model sys_i can be a TransferFunctionModel, StateSpaceModel, AffineStateSpaceModel, or NonlinearStateSpaceModel.
The inputs and outputs of the system produced by SystemsModelSeriesConnect are the inputs of sys₁ and the outputs of sys₂, respectively.

The arguments in_1i and out_1i are integers specifying the positions of the input or output channels.

Examples

open all close all

Basic Examples (4)

Connect two continuous-time systems in series:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{1}}, s*α}, s], TransferFunctionModel[{{{b + s}}, a + s}, 
 s]]

Connect two discrete-time systems in series:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{b + z}}, a + z}, 
 z, SamplingPeriod -> τ], TransferFunctionModel[{{{z + β}}, z + α}, 
 z, SamplingPeriod -> τ]]

Connect state-space systems:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{0, 1}, {-Subscript[α, 0], -Subscript[α, 1]}}, 
  {{0}, {1}}, {{Subscript[β, 0], Subscript[β, 1]}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{0, 1, 0}, {0, 0, 1}, {-Subscript[a, 0], 
    -Subscript[a, 1], -Subscript[a, 2]}}, {{0}, {0}, {1}}, 
  {{Subscript[b, 0], Subscript[b, 1], Subscript[b, 2]}}, 
  {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Connect the second output from the first system to the first input of the second system:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{Subscript[k, 1]}, {Subscript[k, 2]}}, 
  {{z + Subscript[β, 1]}, 
   {z + Subscript[β, 2]}}}, z, SamplingPeriod -> 1], TransferFunctionModel[{{{b}}, a + z}, z, 
 SamplingPeriod -> 1], {2, 1}]

Scope (13)

Basic Uses (5)

Connect scalar systems:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{Subscript[a, 11], Subscript[a, 12]}, 
   {Subscript[a, 21], Subscript[a, 22]}}, 
  {{Subscript[b, 11]}, {Subscript[b, 21]}}, 
  {{Subscript[c, 11], Subscript[c, 12]}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None], StateSpaceModel[{{{Subscript[α, 11], Subscript[α, 12]}, 
   {Subscript[α, 21], Subscript[α, 22]}}, 
  {{Subscript[β, 11]}, {Subscript[β, 21]}}, 
  {{Subscript[γ, 11], Subscript[γ, 12]}}, {{0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

Connect multivariable systems:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{Subscript[a, 11], Subscript[a, 12]}, 
   {Subscript[a, 21], Subscript[a, 22]}}, 
  {{Subscript[b, 11]}, {Subscript[b, 21]}}, 
  {{Subscript[c, 11], Subscript[c, 12]}, 
   {Subscript[c, 21], Subscript[c, 22]}}, {{0}, {0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{Subscript[α, 11], Subscript[α, 12]}, 
   {Subscript[α, 21], Subscript[α, 22]}}, 
  {{Subscript[β, 11], Subscript[β, 12]}, 
   {Subscript[β, 21], Subscript[β, 22]}}, 
  {{Subscript[γ, 11], Subscript[γ, 12]}}, {{0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

Connect the second output from the first system to the first input of the second system:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{Subscript[a, 11], Subscript[a, 12]}, 
   {Subscript[a, 21], Subscript[a, 22]}}, 
  {{Subscript[b, 11], Subscript[b, 12]}, 
   {Subscript[b, 21], Subscript[b, 22]}}, 
  {{Subscript[c, 11], Subscript[c, 12]}, 
   {Subscript[c, 21], Subscript[c, 22]}}, 
  {{Subscript[d, 11], Subscript[d, 12]}, 
   {Subscript[d, 21], Subscript[d, 22]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None], StateSpaceModel[{{{Subscript[α, 11], Subscript[α, 12]}, 
   {Subscript[α, 21], Subscript[α, 22]}}, 
  {{Subscript[β, 11], Subscript[β, 12]}, 
   {Subscript[β, 21], Subscript[β, 22]}}, 
  {{Subscript[γ, 11], Subscript[γ, 12]}}, 
  {{Subscript[D, 11], Subscript[D, 12]}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {2, 1}]

Connect discrete-time systems:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{Subscript[p, 1]}}, {{1}}, {{Subscript[k, 1]}}, {{0}}}, 
 SamplingPeriod -> τ, SystemsModelLabels -> None], StateSpaceModel[{{}, {}, {}, {{Subscript[k, 2]}}}, SamplingPeriod -> τ, 
 SystemsModelLabels -> None]]

Connect a StateSpaceModel to a TransferFunctionModel:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{Subscript[a, 11], Subscript[a, 12]}, 
   {Subscript[a, 21], Subscript[a, 22]}}, 
  {{Subscript[b, 11]}, {Subscript[b, 21]}}, 
  {{Subscript[c, 11], Subscript[c, 12]}}, {{0}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None], TransferFunctionModel[{{{k}}, s + α}, s]]

System Types (8)

Connect two TransferFunctionModel systems:

Wolfram Language code: SystemsModelSeriesConnect[TransferFunctionModel[{{{a}}, p + s}, s], TransferFunctionModel[{{{α}}, s + ρ}, s]]

With delays:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{a/E^(s*T)}}, 
  p + s}, s], TransferFunctionModel[{{{α/E^(s*τ)}}, 
  s + ρ}, s]]

Using improper transfer functions:

Wolfram Language code: SystemsModelSeriesConnect[TransferFunctionModel[{{{a + s}}, 1}, s], TransferFunctionModel[{{{s + α}}, 1}, s]]

Connect two StateSpaceModel systems:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{α}}, {{β}}, {{γ}}, 
  {{ρ}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

With delays:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{a + SystemsModelDelay[Subscript[τ, 1]]}}, 
  {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None], StateSpaceModel[{{{α + SystemsModelDelay[Subscript[τ, 2]]}}, 
  {{β}}, {{γ}}, {{ρ}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

Using descriptor state-space models:

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}, 
  {{e}}}, SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{α}}, {{β}}, {{γ}}, 
  {{ρ}}, {{η}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Input linear AffineStateSpaceModel systems:

Wolfram Language code:

SystemsModelSeriesConnect[AffineStateSpaceModel[{{a[Subscript[x, 1]]}, 
  {{b[Subscript[x, 1]]}}, {c[Subscript[x, 1]]}, 
  {{d[Subscript[x, 1]]}}}, {Subscript[x, 1]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], AffineStateSpaceModel[{{α[Subscript[x, 2]]}, 
  {{β[Subscript[x, 2]]}}, 
  {γ[Subscript[x, 2]]}, 
  {{ρ[Subscript[x, 2]]}}}, {Subscript[x, 2]}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

General nonlinear NonlinearStateSpaceModel systems:

Wolfram Language code:

SystemsModelSeriesConnect[NonlinearStateSpaceModel[{{Subscript[f, 1][Subscript[x, 1], 
    Subscript[u, 1]]}, {Subscript[h, 1][Subscript[x, 1], 
    Subscript[u, 1]]}}, {Subscript[x, 1]}, 
 {Subscript[u, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], NonlinearStateSpaceModel[{{Subscript[f, 2][Subscript[x, 2], 
    Subscript[u, 2]]}, {Subscript[h, 2][Subscript[x, 2], 
    Subscript[u, 2]]}}, {Subscript[x, 2]}, 
 {Subscript[u, 2]}, {Automatic}, Automatic, SamplingPeriod -> None]]

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

Wolfram Language code:

Subscript[ssm, 1] = SystemsModelSeriesConnect[TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, 
  s + Subscript[p, 1]}, s], StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None]]

Reversing the order gives an equivalent state-space model:

Wolfram Language code:

Subscript[ssm, 2] = SystemsModelSeriesConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, 
  s + Subscript[p, 1]}, s]]

They give the same transfer functions:

Wolfram Language code: TransferFunctionModel /@ {Subscript[ssm, 1], Subscript[ssm, 2]}//Simplify

Connection with delays:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{(k*(s + Subscript[z, 1]))/
     E^(s*Subscript[τ, 1])}}, 
  s + Subscript[p, 1]}, s], StateSpaceModel[{{{a + SystemsModelDelay[Subscript[τ, 2]]}}, 
  {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]]

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

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, 
  s + Subscript[p, 1]}, s], AffineStateSpaceModel[{{α[x]}, {{β[x]}}, 
  {γ[x]}, {{ρ[x]}}}, {x}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], AffineStateSpaceModel[{{α[x]}, {{β[x]}}, 
  {γ[x]}, {{ρ[x]}}}, {x}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

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

Wolfram Language code:

SystemsModelSeriesConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> None], NonlinearStateSpaceModel[{{f[x, u]}, 
  {h[x, u]}}, {x}, {u}, 
 {Automatic}, Automatic, SamplingPeriod -> None]]

Wolfram Language code:

SystemsModelSeriesConnect[AffineStateSpaceModel[{{a[x]}, {{b[x]}}, 
  {c[x]}, {{d[x]}}}, {x}, 
 {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], NonlinearStateSpaceModel[{{f[x, u]}, 
  {h[x, u]}}, {x}, {u}, 
 {Automatic}, Automatic, SamplingPeriod -> None]]

Applications (4)

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

Wolfram Language code: cascade[s__] := Fold[SystemsModelSeriesConnect, First[{s}], Rest[{s}]]

Connect a family of first-order systems in series:

Wolfram Language code: cascade@@Table[TransferFunctionModel[{{{1}}, i + s}, s], {i, 0, 3}]

Connect several multiple-input, multiple-output systems:

Wolfram Language code:

cascade[TransferFunctionModel[{{{1, 1}, {s, 1}, {1, 1}}, 
  {{s, 1 + s}, {3 + s, s}, 
   {1 + s, 3 + s}}}, s], TransferFunctionModel[{{{1, 3, 1 + s}}, 
  {{1 + s, 1 + s, 3 + s}}}, s], TransferFunctionModel[{{{2}, {2*s}}, 1 - 4*s + s^2}, 
 s], TransferFunctionModel[{{{1, 0}, {0, 1}}, {{1 + 10*s, 1}, {1, 1 + 5*s}}}, 
 s]]

The cascade of four abstract systems:

Wolfram Language code: cascade[s1, s2, s3, s4];

The tree structure of the cascade:

Wolfram Language code: TreeForm[%]

Create a positioning system with a power amplifier, motor, and angular rate sensor in series:

Wolfram Language code:

{amp, motor, sensor} = {TransferFunctionModel[{{{10}}, 10 + s}, s], TransferFunctionModel[{{{0.5}}, s*(2 + s)}, s], TransferFunctionModel[{{{s}}, 1}, s]};

Wolfram Language code: tfm = SystemsModelSeriesConnect[amp, SystemsModelSeriesConnect[motor, sensor]]

Visualize the open-loop step response:

Wolfram Language code: Plot[Evaluate@OutputResponse[tfm, UnitStep[t], {t, 5}], {t, 0, 5}, PlotRange -> All]

Integrate the last output of a three-output system:

Wolfram Language code:

tfm = TransferFunctionModel[{{{s, s}, {-s, -s}, 
   {1, s}}, {{(1 + s)*(2 + s)^2, (2 + s)^2}, 
   {(2 + s)^2, (2 + s)^2}, {(2 + s)^2, 
    (1 + s)^2}}}, s];
SystemsModelSeriesConnect[tfm, TransferFunctionModel[{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, 
  {{1, 1, 1}, {1, 1, 1}, {1, 1, s}}}, s]]

Use SystemsModelSeriesConnect in multi-loop reduction:

Wolfram Language code:

{G1, G2, G3, G4, H1, H2, H3} = {TransferFunctionModel[{{{1}}, 10 + s}, s], TransferFunctionModel[{{{1}}, 1 + s}, s], TransferFunctionModel[{{{1 + s^2}}, 4 + 4*s + s^2}, 
 s], TransferFunctionModel[{{{1 + s}}, 6 + s}, s], TransferFunctionModel[{{{1 + s}}, 2 + s}, s], TransferFunctionModel[{{{2*(6 + s)}}, 1 + s}, s], TransferFunctionModel[{{{1}}, 1}, s]};

Wolfram Language code:

sys1 = SystemsModelSeriesConnect[G3, G4];
sys2 = SystemsModelFeedbackConnect[sys1, H1, "Positive"];
sys3 = SystemsModelSeriesConnect[G2, sys2];
sys4 = SystemsModelFeedbackConnect[sys3, H2];
sys5 = SystemsModelSeriesConnect[G1, sys4];
SystemsModelFeedbackConnect[sys5, H3]//Simplify

Properties & Relations (8)

The resulting system has the inputs of the first system and the outputs of the second system:

Wolfram Language code:

{ssm1, ssm2} = {StateSpaceModel[{{{Subscript[a, 1, 1], Subscript[a, 1, 2]}, 
   {Subscript[a, 2, 1], Subscript[a, 2, 2]}}, 
  {{Subscript[b, 1, 1], Subscript[b, 1, 2]}, 
   {Subscript[b, 2, 1], Subscript[b, 2, 2]}}, 
  {{Subscript[c, 1, 1], Subscript[c, 1, 2]}, 
   {Subscript[c, 2, 1], Subscript[c, 2, 2]}, 
   {Subscript[c, 3, 1], Subscript[c, 3, 2]}}, {{0, 0}, {0, 0}, {0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> 
  {{Subscript[u, 11], Subscript[u, 12]}}], StateSpaceModel[{{{Subscript[A, 1, 1], Subscript[A, 1, 2], 
    Subscript[A, 1, 3]}, {Subscript[A, 2, 1], 
    Subscript[A, 2, 2], Subscript[A, 2, 3]}, 
   {Subscript[A, 3, 1], Subscript[A, 3, 2], 
    Subscript[A, 3, 3]}}, {{Subscript[b, 1, 1], 
    Subscript[b, 1, 2], Subscript[b, 1, 3]}, 
   {Subscript[b, 2, 1], Subscript[b, 2, 2], 
    Subscript[b, 2, 3]}, {Subscript[b, 3, 1], 
    Subscript[b, 3, 2], Subscript[b, 3, 3]}}, 
  {{Subscript[c, 1, 1], Subscript[c, 1, 2], 
    Subscript[c, 1, 3]}, {Subscript[c, 2, 1], 
    Subscript[c, 2, 2], Subscript[c, 2, 3]}}, {{0, 0, 0}, {0, 0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> 
  {{}, {Subscript[y, 21], Subscript[y, 22]}, {}}]};

Wolfram Language code: SystemsModelSeriesConnect[ssm1, ssm2, {1, 3}]

SystemsModelSeriesConnect is a special case of SystemsConnectionsModel:

Wolfram Language code:

{Subscript[ssm, 1], Subscript[ssm, 2]} = {StateSpaceModel[{{{Subscript[a, 1]}}, {{Subscript[b, 1]}}, 
  {{Subscript[c, 1]}}, {{Subscript[d, 1]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None], StateSpaceModel[{{{Subscript[a, 2]}}, {{Subscript[b, 2]}}, 
  {{Subscript[c, 2]}}, {{Subscript[d, 2]}}}, SamplingPeriod -> None, 
 SystemsModelLabels -> None]};

Wolfram Language code: SystemsModelSeriesConnect[Subscript[ssm, 1], Subscript[ssm, 2]]

Wolfram Language code: SystemsModelMerge[SystemsConnectionsModel[{Subscript[ssm, 1], Subscript[ssm, 2]}, {{1, 1} -> {2, 1}}, {1, 1}, {2, 1}]]

SystemsModelSeriesConnect does not cancel poles and zeros:

Wolfram Language code:

SystemsModelSeriesConnect[TransferFunctionModel[{{{-1 + 2*z}}, 0.125 + 0.5*z + z^2}, 
 z, SamplingPeriod -> 1], TransferFunctionModel[{{{0.5 + 3*z}}, (-0.8 + z)*
   (-1 + 2*z)}, z, SamplingPeriod -> 1]]

A system made from series and parallel connections has the same poles as the subsystems:

Wolfram Language code:

{g1, g2, g3, g4} = {TransferFunctionModel[{{{-1 + 2*z}}, -0.3 + z}, z, 
 SamplingPeriod -> 1], TransferFunctionModel[{{{0.5 + 3*z}}, 0.125 - 0.25*z + z^2}, 
 z, SamplingPeriod -> 1], TransferFunctionModel[{{{0.5 + z}}, 0.75 + z}, z, 
 SamplingPeriod -> 1], TransferFunctionModel[{{{0.15*z}}, 0.8 + z}, z, 
 SamplingPeriod -> 1]};

Assemble the system:

Wolfram Language code: sys = SystemsModelSeriesConnect[SystemsModelParallelConnect[g3, SystemsModelSeriesConnect[g1, g2]], g4]

It's poles:

Wolfram Language code: TransferFunctionPoles[sys]//Flatten

They're the same as the poles of its individual components:

Wolfram Language code: Complement[Flatten[TransferFunctionPoles /@ {g1, g2, g3, g4}], %]

The order of the reduced system is the sum of the orders of the subsystems:

Wolfram Language code:

{ssm1, ssm2} = {StateSpaceModel[{{{-0.75}}, {{1}}, {{-0.25}}, {{1}}}, SamplingPeriod -> 1, 
 SystemsModelLabels -> None], StateSpaceModel[{{{0, 1, 0}, {0, 0, 1}, {-0.48, 0.64, 0.75}}, {{0}, {0}, {1}}, {{0, 0.15, 0}}, 
  {{0}}}, SamplingPeriod -> 1, SystemsModelLabels -> None]};

The connected system has an order of 4:

Wolfram Language code: SystemsModelOrder[SystemsModelSeriesConnect[ssm1, ssm2]]

It is the sum of the individual model orders:

Wolfram Language code: Total[SystemsModelOrder /@ {ssm1, ssm2}]

SystemsModelSeriesConnect is essentially a flat function:

Wolfram Language code:

{Subscript[tfm, 1], Subscript[tfm, 2], Subscript[tfm, 3]} = TransferFunctionModel /@ {m1, m2, m3};
SystemsModelSeriesConnect[SystemsModelSeriesConnect[Subscript[tfm, 1], Subscript[tfm, 2]], Subscript[tfm, 3]]

Wolfram Language code: SystemsModelSeriesConnect[Subscript[tfm, 1], SystemsModelSeriesConnect[Subscript[tfm, 2], Subscript[tfm, 3]]]

Series connections are equivalent to multiplication without any pole-zero cancellation:

Wolfram Language code:

{Subscript[tfm, 1], Subscript[tfm, 2]} = {TransferFunctionModel[{{{Subscript[m1, 1, 1], Subscript[m1, 1, 2]}, 
   {Subscript[m1, 2, 1], Subscript[m1, 2, 2]}}, 1}, ], TransferFunctionModel[{{{Subscript[m2, 1, 1], Subscript[m2, 1, 2]}}, 1}, 
 ]};

Wolfram Language code: SystemsModelSeriesConnect[Subscript[tfm, 1], Subscript[tfm, 2]]

Wolfram Language code: TransferFunctionModel[Subscript[tfm, 2][s].Subscript[tfm, 1][s], s]

The series connection of two models is the convolution of their impulse responses:

Wolfram Language code:

{Subscript[tfm, 1], Subscript[tfm, 2]} = {TransferFunctionModel[{{{1, 1}, {1, 1}}, {{-1 + s, s}, 
   {s, 3 + s}}}, s], TransferFunctionModel[{{{1, 1}}, {{2 + s, 4 + s}}}, s]};

Their Laplace transforms:

Wolfram Language code:

LaplaceTransform[Subsuperscript[∫, 0, t]InverseLaplaceTransform[Subscript[tfm, 2][s], s, τ].InverseLaplaceTransform[Subscript[tfm, 1][s], s, t - τ] ⅆτ, t, s]

A series connection gives the same result:

Wolfram Language code: SystemsModelSeriesConnect[Subscript[tfm, 1], Subscript[tfm, 2]][s] - %//Simplify

Possible Issues (1)

Multiple outputs of sys₁ cannot be connected to a single input of sys₂:

Wolfram Language code:

{sys1, sys2} = {StateSpaceModel[{{{Subscript[a, 1, 1], Subscript[a, 1, 2]}, 
   {Subscript[a, 2, 1], Subscript[a, 2, 2]}}, 
  {{Subscript[b, 1, 1], Subscript[b, 1, 2]}, 
   {Subscript[b, 2, 1], Subscript[b, 2, 2]}}, 
  {{Subscript[c, 1, 1], Subscript[c, 1, 2]}, 
   {Subscript[c, 2, 1], Subscript[c, 2, 2]}, 
   {Subscript[c, 3, 1], Subscript[c, 3, 2]}}, {{0, 0}, {0, 0}, {0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> {{}, {X, X, None}}], StateSpaceModel[{{{Subscript[A, 1, 1], Subscript[A, 1, 2], 
    Subscript[A, 1, 3]}, {Subscript[A, 2, 1], 
    Subscript[A, 2, 2], Subscript[A, 2, 3]}, 
   {Subscript[A, 3, 1], Subscript[A, 3, 2], 
    Subscript[A, 3, 3]}}, {{Subscript[B, 1, 1], 
    Subscript[B, 1, 2], Subscript[B, 1, 3]}, 
   {Subscript[B, 2, 1], Subscript[B, 2, 2], 
    Subscript[B, 2, 3]}, {Subscript[B, 3, 1], 
    Subscript[B, 3, 2], Subscript[B, 3, 3]}}, 
  {{Subscript[C, 1, 1], Subscript[C, 1, 2], Subscript[C, 1, 3]}, 
   {Subscript[C, 2, 1], Subscript[C, 2, 2], Subscript[C, 2, 3]}}, {{0, 0, 0}, {0, 0, 0}}}, 
 SamplingPeriod -> None, SystemsModelLabels -> {{None, None, X}}]};

Wolfram Language code: SystemsModelSeriesConnect[sys1, sys2, {{1, 3}, {2, 3}}]

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

SystemsModelSeriesConnect

Details

Examples

Basic Examples (4)

Scope (13)

Basic Uses (5)

System Types (8)

Applications (4)

Properties & Relations (8)

Possible Issues (1)

Text

CMS

APA

BibTeX

BibLaTeX

SystemsModelSeriesConnect

Details

Examples

Basic Examples (4)

Scope (13)

Basic Uses (5)

System Types (8)

Applications (4)

Properties & Relations (8)

Possible Issues (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX