WOLFRAM

Wolfram Language & System Documentation Center

SystemsModelFeedbackConnect[sys]

connects the outputs from sys to the inputs with negative feedback.

SystemsModelFeedbackConnect[sys,{con1,…}]

only feedback connect the outputs and inputs in coni.

SystemsModelFeedbackConnect[sys1,sys2]

connects the outputs of sys1 to sys2 and the outputs of sys2 to the inputs of sys1 in feedback.

SystemsModelFeedbackConnect[sys1,sys2,{out1,…},{{in1,ftype1},…}]

connects output outi of sys1 to the i^(th) input of sys2 and the j^(th) output of sys2 to input inj of sys1 with feedback type ftypej.

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

SystemsModelFeedbackConnect

SystemsModelFeedbackConnect[sys]

connects the outputs from sys to the inputs with negative feedback.

SystemsModelFeedbackConnect[sys,{con1,…}]

only feedback connect the outputs and inputs in coni.

SystemsModelFeedbackConnect[sys1,sys2]

connects the outputs of sys1 to sys2 and the outputs of sys2 to the inputs of sys1 in feedback.

SystemsModelFeedbackConnect[sys1,sys2,{out1,…},{{in1,ftype1},…}]

connects output outi of sys1 to the i^(th) input of sys2 and the j^(th) output of sys2 to input inj of sys1 with feedback type ftypej.

Details

  • The systems model sysi can be a TransferFunctionModel, StateSpaceModel, AffineStateSpaceModel, or NonlinearStateSpaceModel.
  • Connections coni can be given as:
  • {out,in}connect output out to input in in negative feedback
    {out,in,ftype}use positive or negative feedback type ftype
  • By default, sys2 is a unity gain system.
  • The arguments in, out, ini, and outi are integers specifying the positions of the input or output channels.
  • The ftype can be specified as "Negative" or -1 for negative feedback, and "Positive" or 1 for positive feedback. The default type is "Negative".

Examples

open all close all

Basic Examples  (6)

A transfer function with negative unity feedback:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{k}}, 1 + s*τ}, s]]

Connect two continuous-time systems in negative feedback:

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

Connect two discrete-time systems in negative feedback:

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

A state-space system with negative feedback:

Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Connect two state-space systems:

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

Feedback the second output to the first input:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{Subscript[k, 1]}, {Subscript[k, 2]}}, {{z + Subscript[β, 1]}, {z + Subscript[β, 2]}}}, z, SamplingPeriod -> 1], {2, 1}]

Scope  (18)

Basic Uses  (10)

A unity negative feedback system:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{Subscript[α, 1]}}, s + Subscript[β, 1]}, s]]

A positive feedback system:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{Subscript[α, 1]}}, s + Subscript[β, 1]}, s], "Positive"]

Connect two scalar systems:

Wolfram Language code: SystemsModelFeedbackConnect[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: SystemsModelFeedbackConnect[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 to the first input:

Wolfram Language code: SystemsModelFeedbackConnect[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]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {2, 1}]

Connect the second output to the first input through a feedback system:

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

Connect discrete-time systems:

Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{Subscript[p, 1]}}, {{1}}, {{Subscript[k, 1]}}, {{0}}}, SamplingPeriod -> T, SystemsModelLabels -> None], StateSpaceModel[{{}, {}, {}, {{Subscript[k, 2]}}}, SamplingPeriod -> T, SystemsModelLabels -> None]]

Connect two systems in positive feedback:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{Subscript[α, 1]}}, s + Subscript[β, 1]}, s], TransferFunctionModel[{{{Subscript[γ, 2]}}, s + Subscript[δ, 2]}, s], "Positive"]

Connect two state-space models as shown in the diagram:

Wolfram Language code: SystemsModelFeedbackConnect[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[a, 1], 0}, {0, Subscript[a, 2]}}, {{Subscript[b, 1], 0}, {0, Subscript[b, 2]}}, {{Subscript[c, 1], 0}, {0, Subscript[c, 2]}}, {{0, 0}, {0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {1, 2}, {{2, "Positive"}, {1, "Negative"}}]

Connect a StateSpaceModel to a TransferFunctionModel:

Wolfram Language code: SystemsModelFeedbackConnect[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: SystemsModelFeedbackConnect[TransferFunctionModel[{{{a}}, p + s}, s], TransferFunctionModel[{{{α}}, s + ρ}, s]]

With delays:

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

Using improper transfer functions:

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

Connect two StateSpaceModel systems:

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

With delays:

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

Input linear AffineStateSpaceModel systems:

Wolfram Language code: SystemsModelFeedbackConnect[AffineStateSpaceModel[{{a[Subscript[x, 1]]}, {{b[Subscript[x, 1]]}}, {c[Subscript[x, 1]]}, {{0}}}, {Subscript[x, 1]}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], AffineStateSpaceModel[{{α[Subscript[x, 2]]}, {{β[Subscript[x, 2]]}}, {γ[Subscript[x, 2]]}, {{0}}}, {Subscript[x, 2]}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

General nonlinear NonlinearStateSpaceModel systems:

Wolfram Language code: SystemsModelFeedbackConnect[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[x, 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: SystemsModelFeedbackConnect[TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, s + Subscript[p, 1]}, s], StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

Connection with delays:

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{k/E^(s*Subscript[τ, 1])}}, s + Subscript[p, 1]}, s, SamplingPeriod -> None, SystemsModelLabels -> None], StateSpaceModel[{{{a + SystemsModelDelay[Subscript[τ, 2]]}}, {{b}}, {{c}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]]

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

Wolfram Language code: SystemsModelFeedbackConnect[TransferFunctionModel[{{{k*(s + Subscript[z, 1])}}, s + Subscript[p, 1]}, s], AffineStateSpaceModel[{{α[x]}, {{β[x]}}, {γ[x]}, {{0}}}, {x}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]
Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, SystemsModelLabels -> None], AffineStateSpaceModel[{{α[x]}, {{β[x]}}, {γ[x]}, {{0}}}, {x}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None]]

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

Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}}, SamplingPeriod -> None, SystemsModelLabels -> None], NonlinearStateSpaceModel[{{f[x, u]}, {x}}, {x}, {u}, {Automatic}, Automatic, SamplingPeriod -> None]]
Wolfram Language code: SystemsModelFeedbackConnect[AffineStateSpaceModel[{{a[x]}, {{b[x]}}, {c[x]}, {{d[x]}}}, {x}, {Subscript[, 1]}, {Automatic}, Automatic, SamplingPeriod -> None], NonlinearStateSpaceModel[{{f[x, u]}, {x}}, {x}, {u}, {Automatic}, Automatic, SamplingPeriod -> None]]

Generalizations & Extensions  (2)

Use one feedback type for all connections:

Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, {0, 0, Subscript[a, 3]}}, {{Subscript[b, 1], 0, 0}, {0, Subscript[b, 2], 0}, {0, 0, Subscript[b, 3]}}, {{Subscript[c, 1], 0, 0}, {0, Subscript[c, 2], 0}, {0, 0, Subscript[c, 3]}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], "Positive"]

Connect two systems with positive feedback:

Wolfram Language code: SystemsModelFeedbackConnect[StateSpaceModel[{{{Subscript[a, 1], 0, 0}, {0, Subscript[a, 2], 0}, {0, 0, Subscript[a, 3]}}, {{Subscript[b, 1], 0, 0}, {0, Subscript[b, 2], 0}, {0, 0, Subscript[b, 3]}}, {{Subscript[c, 1], 0, 0}, {0, Subscript[c, 2], 0}, {0, 0, Subscript[c, 3]}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], TransferFunctionModel[{{{Subscript[k, 1], 0, 0}, {0, Subscript[k, 2], 0}, {0, 0, Subscript[k, 3]}}, 1}, s], "Positive"]

Applications  (5)

Obtain the closed-loop transfer function of a discrete-time system with an integral controller and feedback sensor:

Wolfram Language code: {gp, gc, h} = {TransferFunctionModel[{{{0.003 + 0.0031*z}}, 0.905 - 1.9*z + z^2}, z, SamplingPeriod -> 0.04], TransferFunctionModel[{{{0.02*z}}, -1 + z}, z, SamplingPeriod -> 0.04], TransferFunctionModel[{{{0.55}}, -0.45 + z}, z, SamplingPeriod -> 0.04]};
Wolfram Language code: fwdpath = SystemsModelSeriesConnect[gp, gc]
Wolfram Language code: SystemsModelFeedbackConnect[fwdpath, h]

A motor-load servo system with position and velocity feedback:

Wolfram Language code: motorLoadDynamics = TransferFunctionModel[{{{15.82}}, s^2*(10 + s)}, s];

With only position feedback, the system is unstable:

Wolfram Language code: SystemsModelFeedbackConnect[motorLoadDynamics]//TransferFunctionPoles

The closed-loop system, with rate feedback in the inner loop and position feedback in the outer loop:

Wolfram Language code: closedLoopDynamics = SystemsModelFeedbackConnect[SystemsModelFeedbackConnect[motorLoadDynamics, TransferFunctionModel[{{{1.1*s}}, 1}, s]]]//Simplify

The response to a unit step:

Wolfram Language code: Plot[OutputResponse[closedLoopDynamics, UnitStep[t], {t, 10}]//Evaluate, {t, 0, 10}, PlotRange -> All, GridLines -> Automatic]

Use SystemsModelFeedbackConnect 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]; Simplify@SystemsModelFeedbackConnect[sys5, H3]

Compute the complementary sensitivity function from the loop transfer function:

Wolfram Language code: L = TransferFunctionModel[{{{5*s, 4}, {3, 4*s}}, {{2.3 + s, 6 + s}, {1 + s, 6 + s}}}, s]; SystemsModelFeedbackConnect[L, {{1, 1}, {2, 2}}]

A crankshaft receives a delayed input signal from the engine controller:

Wolfram Language code: crankshaft = StateSpaceModel[J w'[t] == Subscript[t, i][t - τ] - Subscript[t, f][t] - Subscript[t, l][t], w[t], {Subscript[t, i][t], Subscript[t, f][t], Subscript[t, l][t]}, w[t], t]

Including a simple controller shows the delay is internal to the closed-loop system:

Wolfram Language code: SystemsModelFeedbackConnect[crankshaft, TransferFunctionModel[k, s], {1}, {1}]

Properties & Relations  (3)

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

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, 1], Subscript[y, 2]}}], StateSpaceModel[{{{α}}, {{β}}, {{γ}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None]};
Wolfram Language code: SystemsModelFeedbackConnect[Subscript[ssm, 1], Subscript[ssm, 2], {1}, {1}]

SystemsModelFeedbackConnect is a special case of SystemsConnectionsModel:

Wolfram Language code: {Subscript[sys, 1], Subscript[sys, 2]} = {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]};
Wolfram Language code: SystemsModelFeedbackConnect[Subscript[sys, 1], Subscript[sys, 2]]
Wolfram Language code: SystemsConnectionsModel[{Subscript[sys, 1], Subscript[sys, 2], StateSpaceModel[{{}, {}, {}, {{1, -1}}}, SamplingPeriod -> None, SystemsModelLabels -> None]}, {{3, 1} -> {1, 1}, {1, 1} -> {2, 1}, {2, 1} -> {3, 2}}, {{3, 1}}, {{1, 1}}]//SystemsModelMerge

Connect two transfer functions tfm1 and tfm2:

Wolfram Language code: Subscript[tfm, 1] = TransferFunctionModel[RandomReal[5, {3, 3}]]; Subscript[tfm, 2] = TransferFunctionModel[RandomReal[5, {3, 3}]];SystemsModelFeedbackConnect[Subscript[tfm, 1], Subscript[tfm, 2]]

This is equivalent to (IdentityMatrix[n]+tfm1.tfm2)-1.tfm1:

Wolfram Language code: TransferFunctionModel[Inverse[IdentityMatrix[3] + Subscript[tfm, 1][s].Subscript[tfm, 2][s]].Subscript[tfm, 1][s], s]
Wolfram Research (2010), SystemsModelFeedbackConnect, Wolfram Language function, https://reference.wolfram.com/language/ref/SystemsModelFeedbackConnect.html (updated 2014).

Text

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

CMS

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

APA

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

BibTeX

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

BibLaTeX

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