WOLFRAM

Wolfram Language & System Documentation Center

SystemsModelParallelConnect[sys1,sys2]

connects the systems models sys1 and sys2 in parallel.

SystemsModelParallelConnect[sys1,sys2,{{in11,in21},…},{{out11,out21},…}]

connects the inputs in1i to inputs in2i and sums the outputs out1k and outputs out2k.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
System Types  
Generalizations & Extensions  
Applications  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

SystemsModelParallelConnect

SystemsModelParallelConnect[sys1,sys2]

connects the systems models sys1 and sys2 in parallel.

SystemsModelParallelConnect[sys1,sys2,{{in11,in21},…},{{out11,out21},…}]

connects the inputs in1i to inputs in2i and sums the outputs out1k and outputs out2k.

Details

Examples

open all close all

Basic Examples  (4)

Connect two continuous-time systems in parallel:

Wolfram Language code: SystemsModelParallelConnect[TransferFunctionModel[{{{1}}, s*α}, s], TransferFunctionModel[{{{b + s}}, a + s}, s]]

Connect two discrete-time systems in parallel:

Wolfram Language code: SystemsModelParallelConnect[TransferFunctionModel[{{{b + z}}, a + z}, z, SamplingPeriod -> T], TransferFunctionModel[{{{z + β}}, z + α}, z, SamplingPeriod -> T]]

Connect state-space systems:

Wolfram Language code: SystemsModelParallelConnect[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]]

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

Wolfram Language code: {sys1, sys2} = {TransferFunctionModel[{{{Subscript[k, 1]}, {Subscript[k, 2]}}, {{z + Subscript[β, 1]}, {z + Subscript[β, 2]}}}, z, SamplingPeriod -> 1], TransferFunctionModel[{{{b}}, a + z}, z, SamplingPeriod -> 1]};

Merge no inputs and sum no outputs:

Wolfram Language code: SystemsModelParallelConnect[sys1, sys2, None, None]

Merge inputs and sum no outputs:

Wolfram Language code: SystemsModelParallelConnect[sys1, sys2, All, None]

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

Wolfram Language code: SystemsModelParallelConnect[sys1, sys2, None, {{2, 1}}]

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

Wolfram Language code: SystemsModelParallelConnect[sys1, sys2, All, {{2, 1}}]

Scope  (14)

Basic Uses  (7)

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

Wolfram Language code: {Subscript[tfm, 1], Subscript[tfm, 2]} = {TransferFunctionModel[{{{Subscript[a, 1], Subscript[a, 2]}}, s}, s], TransferFunctionModel[{{{b}}, s}, s]};

Use the first input of the two-input system:

Wolfram Language code: SystemsModelParallelConnect[Subscript[tfm, 1], Subscript[tfm, 2], {{1, 1}}, All]

Use the second input:

Wolfram Language code: SystemsModelParallelConnect[Subscript[tfm, 1], Subscript[tfm, 2], {{2, 1}}, All]

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

Wolfram Language code: {Subscript[tfm, 1], Subscript[tfm, 2]} = {TransferFunctionModel[{{{Subscript[a, 1]}, {Subscript[a, 2]}}, s}, s], TransferFunctionModel[{{{b}}, s}, s]};

Use the first output of the two-input system:

Wolfram Language code: SystemsModelParallelConnect[Subscript[tfm, 1], Subscript[tfm, 2], All, {{1, 1}}]

Use the second output:

Wolfram Language code: SystemsModelParallelConnect[Subscript[tfm, 1], Subscript[tfm, 2], All, {{2, 1}}]

Connect scalar systems:

Wolfram Language code: SystemsModelParallelConnect[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: SystemsModelParallelConnect[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]}}, {{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]]

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

Wolfram Language code: SystemsModelParallelConnect[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, 2}}, {{1, 1}}]

Connect a StateSpaceModel to a TransferFunctionModel:

Wolfram Language code: SystemsModelParallelConnect[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]]

Connect discrete-time systems:

Wolfram Language code: SystemsModelParallelConnect[StateSpaceModel[{{{0, 1}, {-5, -6}}, {{0}, {1}}, {{k, 0}}, {{0}}}, SamplingPeriod -> τ], TransferFunctionModel[{{{k}}, 1 + z}, z, SamplingPeriod -> τ]]

System Types  (7)

Connect two TransferFunctionModel systems:

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

With delays:

Wolfram Language code: SystemsModelParallelConnect[TransferFunctionModel[{{{a/E^(s*T)}}, p + s}, s], TransferFunctionModel[{{{α/E^(s*τ)}}, s + ρ}, s]]

Using improper transfer functions:

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

Connect two StateSpaceModel systems:

Wolfram Language code: SystemsModelParallelConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{α}}, {{β}}, {{γ}}, {{ρ}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

With delays:

Wolfram Language code: SystemsModelParallelConnect[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: SystemsModelParallelConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}, {{e}}}, SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{α}}, {{β}}, {{γ}}, {{ρ}}, {{η}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Input linear AffineStateSpaceModel systems:

Wolfram Language code: SystemsModelParallelConnect[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: SystemsModelParallelConnect[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 state-space model will give a state-space model:

Wolfram Language code: ssm1 = SystemsModelParallelConnect[TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, s + Subscript[p, 1]}, s], StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Reversing the order gives an equivalent state-space model:

Wolfram Language code: ssm2 = SystemsModelParallelConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{0}}}, 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 /@ {ssm1, ssm2}//Simplify

Connection with delays:

Wolfram Language code: SystemsModelParallelConnect[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: SystemsModelParallelConnect[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: SystemsModelParallelConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, SystemsModelLabels -> None], AffineStateSpaceModel[{{α[x]}, {{β[x]}}, {γ[x]}, {{ρ[x]}}}, {x}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

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

Wolfram Language code: SystemsModelParallelConnect[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: SystemsModelParallelConnect[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]]

Generalizations & Extensions  (3)

Merge two systems:

Wolfram Language code: {tf1, tf2} = {TransferFunctionModel[{{{1, 1}}, {{s, 1 + s}}}, s], TransferFunctionModel[{{{1}, {1}}, {{2 + s}, {3 + s}}}, s]};
Wolfram Language code: SystemsModelParallelConnect[tfm1, tfm2, {}, {}]

Connect the corresponding inputs:

Wolfram Language code: {tf1, tf2} = {TransferFunctionModel[{{{Subscript[a, 11], Subscript[a, 12]}}, {{1 + s*Subscript[b, 11], 1 + s*Subscript[b, 12]}}}, s], TransferFunctionModel[{{{Subscript[A, 11], Subscript[A, 12]}, {Subscript[A, 21], Subscript[A, 22]}}, {{1 + s*Subscript[B, 11], 1 + s*Subscript[B, 12]}, {1 + s*Subscript[B, 21], 1 + s*Subscript[B, 22]}}}, s]};
Wolfram Language code: SystemsModelParallelConnect[tf1, tf2, All, {}]

Sum the corresponding outputs:

Wolfram Language code: {tf1, tf2} = {TransferFunctionModel[{{{Subscript[a, 11]}, {Subscript[a, 21]}}, {{1 + s*Subscript[b, 11]}, {1 + s*Subscript[b, 21]}}}, s], TransferFunctionModel[{{{Subscript[A, 11]}, {Subscript[A, 21]}}, {{1 + s*Subscript[B, 11]}, {1 + s*Subscript[B, 21]}}}, s]};
Wolfram Language code: SystemsModelParallelConnect[tf1, tf2, {}, All]

Applications  (3)

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

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

Connect a family of first-order systems in parallel:

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

Connect several multiple-input, multiple-output systems:

Wolfram Language code: {Subscript[tfm, 1], Subscript[tfm, 2], Subscript[tfm, 3]} = {TransferFunctionModel[{{{1, 1 + s}, {3*s, 1}}, {{s, s}, {1 + s, 1 + s}}}, s], TransferFunctionModel[{{{4 + s, 4 + s}, {s, s}}, {{6 + s, 3 + s}, {6 + s, 3 + s}}}, s], TransferFunctionModel[{{{5*s, 0}, {0, 1}}, {{1 + s, 1}, {1, 1 + s}}}, s]}; parallel[Subscript[tfm, 1], Subscript[tfm, 2], Subscript[tfm, 3]]

Construct a parallel RLC circuit:

Wolfram Language code: {resistance, inductance, capacitance} = {TransferFunctionModel[{{{1}}, r*s}, s], TransferFunctionModel[{{{1}}, l*s^2}, s], TransferFunctionModel[{{{c}}, 1}, s]};
Wolfram Language code: SystemsModelParallelConnect[resistance, SystemsModelParallelConnect[inductance, capacitance]]//Simplify

Add a disturbance model to the output of a system:

Wolfram Language code: {tfm, disturbanceModel} = {TransferFunctionModel[{{{s, 2.1, 4}, {3, 4*s, 3 + s}}, {{6 + s + s^2, 1 + s, 3.5 + 2*s + s^2}, {1 + s, 6 + s + s^2, 1 + s}}}, s], TransferFunctionModel[{{{-4 + s}}, 13 - 6*s + s^2}, s]};
Wolfram Language code: SystemsModelParallelConnect[tfm, disturbanceModel, {}, {{1, 1}}]

Properties & Relations  (3)

SystemsModelParallelConnect is essentially a summation operation:

Wolfram Language code: SystemsModelParallelConnect[TransferFunctionModel[{{{Subscript[m1, 1, 1], Subscript[m1, 1, 2], Subscript[m1, 1, 3]}, {Subscript[m1, 2, 1], Subscript[m1, 2, 2], Subscript[m1, 2, 3]}}, 1}, s], TransferFunctionModel[{{{Subscript[m2, 1, 1], Subscript[m2, 1, 2], Subscript[m2, 1, 3]}, {Subscript[m2, 2, 1], Subscript[m2, 2, 2], Subscript[m2, 2, 3]}}, 1}, s]]

SystemsModelParallelConnect is a special case of SystemsConnectionsModel:

Wolfram Language code: {Subscript[sys, 1], Subscript[sys, 2]} = {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]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], 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]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]};
Wolfram Language code: SystemsModelParallelConnect[Subscript[sys, 1], Subscript[sys, 2]]

The common input and summer blocks:

Wolfram Language code: Subscript[com, 1] = Subscript[com, 2] = StateSpaceModel[{{}, {}, {}, {{1}, {1}}}, SamplingPeriod -> None, SystemsModelLabels -> None];
Wolfram Language code: Subscript[sum, 1] = Subscript[sum, 2] = StateSpaceModel[{{}, {}, {}, {{1, 1}}}, SamplingPeriod -> None, SystemsModelLabels -> None];

Use SystemsConnectionsModel to specify the connections:

Wolfram Language code: 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:

Wolfram Language code: SystemsModelMerge[%]

A parallel connection leaves the states of the subsystems unchanged:

Wolfram Language code: {Subscript[ssm, 1], Subscript[ssm, 2]} = {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]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> {{Subscript[u, 1], Subscript[u, 2]}, {Subscript[y, 11], Subscript[y, 12]}, {Subscript[x, 11], Subscript[x, 12]}}], 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]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> {{Subscript[u, 1], Subscript[u, 2]}, {Subscript[y, 21], Subscript[y, 22]}, {Subscript[x, 21], Subscript[x, 22]}}]};
Wolfram Language code: SystemsModelParallelConnect[Subscript[ssm, 1], Subscript[ssm, 2]]

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

Wolfram Language code: sys1 = SystemsModelParallelConnect[Subscript[ssm, 1], Subscript[ssm, 2], {{1, 1}}, {{1, 1}, {2, 2}}]
Wolfram Language code: First[SystemsModelDimensions[sys1]] ≥ Max[First[SystemsModelDimensions[#]]& /@ {Subscript[ssm, 1], Subscript[ssm, 2]}]

A similar result holds for the minimum number of outputs:

Wolfram Language code: 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]}]
Wolfram Research (2010), SystemsModelParallelConnect, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html (updated 2014).

Text

Wolfram Research (2010), SystemsModelParallelConnect, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html (updated 2014).

CMS

Wolfram Language. 2010. "SystemsModelParallelConnect." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html.

APA

Wolfram Language. (2010). SystemsModelParallelConnect. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html

BibTeX

@misc{reference.wolfram_2026_systemsmodelparallelconnect, author="Wolfram Research", title="{SystemsModelParallelConnect}", year="2014", howpublished="\url{https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_systemsmodelparallelconnect, organization={Wolfram Research}, title={SystemsModelParallelConnect}, year={2014}, url={https://reference.wolfram.com/language/ref/SystemsModelParallelConnect.html}, note=[Accessed: 13-June-2026]}