({{, (RefLink[FullInformationOutputRegulator, paclet:ref/FullInformationOutputRegulator])[sys,rspec]
gives the full state information output regulator for sys using specification rspec.  }, {, (RefLink[FullInformationOutputRegulator, paclet:ref/FullInformationOutputRegulator])[{sys,{(Subscript[out, 1]),…},{(Subscript[in, 1]),…}},…]
specifies the regulated outputs (Subscript[out, i]) and the controlled inputs (Subscript[in, j]).}})

OpenersNotesSection(Spacer1)Details and Options

(RefLink[FullInformationOutputRegulator, paclet:ref/FullInformationOutputRegulator]) returns a regulator that drives the sys outputs to zero and is typically used to suppress or track known inputs to the system.

The system sys is taken to have state equations x'==f(x,w,u) and w'==s(w) and outputs y=g(x,w), with u being the controllable input. The state w is not affected by the input u and is used to model signals to suppress or track, as indicated by the output function g(x,w).

Typical output functions g(x,w), which the regulator will drive to zero:

The system sys can be (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]),  (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]), or (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]).

The computed state feedback k(x,w) regulates sys about an operating point using u=-k(x,w).

The state feedback k(x,w) has the form α(w)+κ.(x-β(w)), where ((∂_w)β(w)).s(w)==f(β(w),α(w),w), g(β(w),w)==0, and κ is computed following rspec.

Possible regulator specifications rspec:

With the specification {"method",pars,opts}, the options opts are passed to the gain computation function.

The outputs {(Subscript[out, 1]),…} and inputs {(Subscript[in, 1]),…} are part specifications and by default are taken to be (RefLink[All, paclet:ref/All]).

OpenersPrimaryExamplesSection(Spacer1)Examples  (19)

OpenersExampleSection0(Spacer1)Basic Examples  (1)

Compute the regulating feedback for a system with a constant disturbance of 0.5:

sys=(AffineStateSpaceModelFull[w+2 (Subscript[x, 1])+(Subscript[x, 2]), (Subscript[x, 1])-2 (Subscript[x, 2]), 0, 1, 0, 0, (Subscript[x, 1])+(Subscript[x, 2]), 0, {(Subscript[x, 1]),0}, {(Subscript[x, 2]),0}, {w,0.5`}, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]);

The regulator is a function of the states {(Subscript[x, 1]),(Subscript[x, 2])} and the disturbance state w:

k=FullInformationOutputRegulator[sys,{"Poles",{-1,-2}}]

The closed-loop system:

csys=SystemsModelStateFeedbackConnect[sys,k]

The output is regulated to zero:

res1=OutputResponse[{sys,{1,1,0.5}},0,{t,0,5}];
res2=OutputResponse[{csys,{1,1,0.5}},0,{t,0,5}];

Plot[{res1,res2},{t,0,5},PlotRange->{0,5},PlotLegends->{"unregulated","regulated"}]

OpenersExampleSection1(Spacer1)Scope  (8)

The regulator for a linear system with the exosystem pole at the origin:

FullInformationOutputRegulator[ssm=(StateSpaceModelFull[p, r, b, 0, 0, 0, c, 0, 0, , , ]),{"Poles",{(Subscript[p, f])}}]

The closed-loop system:

SystemsModelStateFeedbackConnect[ssm,%]//Simplify

The exosystem has a pair of complex poles:

ssm=(StateSpaceModelFull[p, (Subscript[r, 1]), (Subscript[r, 2]), b, 0, 0, ω, 0, 0, -ω, 0, 0, c, 0, 0, 0, , , ]);

Assuming[ω ∈ Reals,FullInformationOutputRegulator[ssm,{"Poles",{(Subscript[p, f])}}]]

The closed-loop system:

SystemsModelStateFeedbackConnect[ssm,%]//Simplify

The exosystem's states are part of the regulator:

ssm=(StateSpaceModelFull[p, (Subscript[r, 1]), (Subscript[r, 2]), b, 0, 0, ω, 0, 0, -ω, 0, 0, c, (Subscript[c, 1]), (Subscript[c, 2]), 0, , , ]);

Assuming[ω ∈ Reals,FullInformationOutputRegulator[ssm,{"Poles",{(Subscript[p, f])}}]]

The closed-loop system:

SystemsModelStateFeedbackConnect[ssm,%]

The response:

OutputResponse[{%,{(Subscript[x, 10]),(Subscript[w, 10]),(Subscript[w, 20])}},0,t]//FullSimplify

The system is regulated if (Subscript[p, f]) is negative:

%/.(Subscript[p, f])->-5/.Thread[{c,(Subscript[c, 1]),(Subscript[c, 2]),(Subscript[x, 10]),(Subscript[w, 10]),(Subscript[w, 20])}->RandomReal[1,6]]

Regulate an (RefLink[AffineStateSpaceModel, paclet:ref/AffineStateSpaceModel]):

Assuming[ω∈Reals,FullInformationOutputRegulator[(AffineStateSpaceModelFull[p x+(x^2)+(Subscript[c, 1]) (Subscript[w, 1])+(Subscript[c, 2]) (Subscript[w, 2]), ω (Subscript[w, 2]), -ω (Subscript[w, 1]), b, 0, 0, x, 0, x, (Subscript[w, 1]), (Subscript[w, 2]), \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]),{"Poles",{(Subscript[p, f])}}]]

Regulate a (RefLink[NonlinearStateSpaceModel, paclet:ref/NonlinearStateSpaceModel]):

FullInformationOutputRegulator[(NonlinearStateSpaceModelFull[p x+w (Subscript[c, 1])+u (Subscript[c, 2])+u w x (Subscript[c, 3]), 0, x, x, w, \[Null], \[Null], {u}Automatic, ]),{"Poles",{(Subscript[p, f])}}]

Specify the regulated outputs and feedback inputs:

FullInformationOutputRegulator[{(StateSpaceModelFull[0, 0, 0, (Subscript[b, 1]), r, p, (Subscript[b, 2]), 0, 1, 0, 0, 0, 0, 1, 0, 0, , , ]),2,1},{"Poles",{(Subscript[p, f])}}]

Use (RefLink[LQRegulatorGains, paclet:ref/LQRegulatorGains]) to compute the stabilizing gains by specifying the weights:

FullInformationOutputRegulator[(AffineStateSpaceModelFull[w+x, 0, 1, 0, x, 0, x, w, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]),{"Weights",{{{1}},{{1}}}}]

Specify the gains to use:

FullInformationOutputRegulator[(AffineStateSpaceModelFull[w+x, 0, 1, 0, x, 0, x, w, \[Null], \[Null], {(Subscript[\[FormalU], 1])}Automatic, ]),{"Gains",{{k}}}]

OpenersExampleSection2(Spacer1)Options  (0)

OpenersExampleSection3(Spacer1)Applications  (6)

Reject a disturbance modeled as (w')'+w==0:

dModel=NonlinearStateSpaceModel[w''[t]+w[t]==0,{{w[t],0},{w'[t],1}},{},{},t];

The full model of the system with disturbance:

nsys=NonlinearStateSpaceModel[{{x[t]+(Subscript[\[FormalX], 1])[t]+v[t]},{x[t]}},{{x[t],0}},{v[t]},Automatic,t];

sys=SystemsModelMerge[{dModel,nsys}]

The regulator:

k=FullInformationOutputRegulator[sys,{"Poles",{-2}}]

The closed-loop system:

csys=SystemsModelStateFeedbackConnect[sys,k]

The output is regulated in the presence of the disturbance:

OutputResponse[{csys,{0,1,1}},0,{t,0,3}];

Plot[%,{t,0,3},PlotRange->All]

Track an input modeled as (w')'+w==0:

iModel=NonlinearStateSpaceModel[w''[t]+w[t]==0,{{w[t],0},{w'[t],1}},{},{},t];

The full model of the system and input model:

nsys=NonlinearStateSpaceModel[{{x[t]+(Subscript[\[FormalX], 1])[t]+v[t]},{x[t],x[t]-(Subscript[\[FormalX], 1])[t]}},{{x[t],0}},{(Subscript[\[FormalX], 1])[t],v[t]},Automatic,t];

sys=SystemsModelMerge[{iModel,nsys}]

The regulator:

k=FullInformationOutputRegulator[{sys,2},{"Poles",{-2}}]

The closed-loop system:

csys=SystemsModelExtract[SystemsModelStateFeedbackConnect[sys,k],All,1]

The output tracks the input:

or=OutputResponse[{csys,{0,1,0.5}},0,{t,0,10}];
Plot[or,{t,0,10},PlotRange->All]

Simultaneously track a step input and reject a sinusoidal disturbance:

iModel=NonlinearStateSpaceModel[{{0},{x-r}},{{r,1}},{}]

dModel=NonlinearStateSpaceModel[{{(Subscript[w, 2]),-(Subscript[w, 1])},{}},{{(Subscript[w, 1]),0},{(Subscript[w, 2]),1}},{}]

The complete system:

nsys=NonlinearStateSpaceModel[{{x+r+(Subscript[w, 1])+v},{x}},{{x,0}},{r,(Subscript[w, 1]),v}]

sys=SystemsModelMerge[{nsys,iModel,dModel}]

Obtain the regulator:

k=FullInformationOutputRegulator[{sys,2},{"Poles",{-8}}]

The closed-loop system:

csys=SystemsModelExtract[SystemsModelStateFeedbackConnect[sys,k],All,1]

The simulation shows the output tracking a step signal:

OutputResponse[NonlinearStateSpaceModel[csys,{x->-1,r->1,(Subscript[w, 1])->0,(Subscript[w, 2])->1}],0,{t,0,5}];
Plot[%,{t,0,5},PlotRange->All]

Regulate an aircraft's longitudinal dynamics in the presence of disturbances:(WebLink[», http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=1356114&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D1356114])

aircraft=(StateSpaceModelFull[0, 14.3877`, 0, -31.5311`, 0.7898`, -0.6526`, -0.335`, 0.4637`, 0.9185`, -0.0012`, -0.4217`, 1, -0.0284`, -0.00588`, 0.0049`, 0.0025`, -0.0035`, -0.0068`, 0.0002`, -0.3816`, -0.4658`, 0, -0.2541`, 0.21`, 0.1078`, -0.1492`, -0.2959`, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, , ,{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3]),(Subscript[x, 4])},{u,(Subscript[w, 1]),(Subscript[w, 2]),(Subscript[w, 3]),(Subscript[w, 4])}, ]);

The disturbances consist of two frequency components:

dist=(StateSpaceModelFull[0, -0.1`, 0, 0, 0.1`, 0, 0, 0, 0, 0, 0, -0.2`, 0, 0, 0.2`, 0, , ,{(Subscript[w, 1]),(Subscript[w, 2]),(Subscript[w, 3]),(Subscript[w, 4])}, ]);

The complete system:

sys=SystemsModelMerge[{aircraft,dist}]

A control law that regulates the output (speed) in the presence of the disturbances:

fb=FullInformationOutputRegulator[sys,{"Poles",{-1,-2,-2.5+I,-2.5-I}}]

The closed-loop system:

csys=SystemsModelStateFeedbackConnect[sys,fb]

Simulation showing regulation being achieved:

OutputResponse[{csys,{0.1,0.001,0,0,1,0,1,0}},0,{t,0,8}];
Plot[%,{t,0,8},PlotRange->All]

The control effort:

fb.StateResponse[{csys,{0.1,0.001,0,0,1,0,1,0}},0,{t,0,150}];
Plot[%,{t,0,150},PlotRange->All]

Regulate a Rössler prototype-4 system:(WebLink[», http://airccse.org/journal/ijfcst/papers/2212ijfcst02.pdf])

asys=(AffineStateSpaceModelFull[-(Subscript[x, 2])-(Subscript[x, 3]), (Subscript[x, 1]), 0.5` ((Subscript[x, 2])-(Subscript[x, 2]^2))-0.5` (Subscript[x, 3]), 0, 0, 1, -w+(Subscript[x, 2]), 0, (Subscript[x, 1]), (Subscript[x, 2]), (Subscript[x, 3]), \[Null], \[Null], AutomaticAutomatic, ]);

Its chaotic behavior:

StateResponse[{asys/.w->0,RandomReal[{-1,1},3]},0,{t,0,300}];
ParametricPlot3D[%,{t,0,300}]

The complete model such that the state (Subscript[x, 2]) is regulated and kept constant:

tmodel=NonlinearStateSpaceModel[{{0},{}},w,{}];
sys=SystemsModelMerge[{asys,tmodel}]

A feedback law:

fb=FullInformationOutputRegulator[sys,{"Poles",{-1,-1.5+I,-1.5-I}}]

The closed-loop system:

csys=SystemsModelStateFeedbackConnect[sys,fb]

Simulations show that (Subscript[x, 2]) is regulated and the system has no chaotic behavior with feedback:

StateResponse[{csys,Join[RandomReal[{-1,1},3],{1}]},0,{t,0,8}];
Plot[Evaluate[Most[%]],{t,0,8},PlotLegends->{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])}]

Regulate the voltage (Subscript[V, 2]) in a Chua circuit to follow a sinusoid while rejecting a disturbance (Subscript[ℰ, 2]) that is the output of another Chua circuit:(WebLink[», http://www.ifac-papersonline.net/cgi-bin/links/page.cgi?g=Detailed%2F27981.html;d=1%3E%E2%88%9E%20%3C%2Findex.html;browse=a%3E%E2%88%9E%20%3C%2Findex.html])

The affine model of the Chua circuit where the nonlinearity is a cubic polynomial:

pars={(Subscript[𝒞, 1])->1,(Subscript[𝒞, 2])->1,ℒ->1,ℛ->1};

asys=(AffineStateSpaceModelFull[((-2 (Subscript[𝒱, 1])-(Subscript[𝒱, 1]^3)+((-(Subscript[𝒱, 1])+(Subscript[𝒱, 2]))/ℛ))/(Subscript[𝒞, 1])), ((-𝒾+(((Subscript[𝒱, 1])-(Subscript[𝒱, 2]))/ℛ))/(Subscript[𝒞, 2])), ((-(Subscript[ℰ, 2])+(Subscript[𝒱, 2]))/ℒ), -(1/(Subscript[𝒞, 1])), 0, 0, -(Subscript[ℰ, 4])+(Subscript[𝒱, 2]), 0, (Subscript[𝒱, 1]), (Subscript[𝒱, 2]), 𝒾, \[Null], \[Null], AutomaticAutomatic, ])/.pars;

The exosystem, where ω is the frequency of the sinusoid to be tracked:

pars1={(Subscript[𝒞, 1])->1,(Subscript[𝒞, 2])->1,ℒ->1,ℛ->1,ω->10};

nsys=(NonlinearStateSpaceModelFull[((-(Subscript[ℰ, 1])-2 (Subscript[ℰ, 1]^3)+((-(Subscript[ℰ, 1])+(Subscript[ℰ, 2]))/ℛ))/(Subscript[𝒞, 1])), (((((Subscript[ℰ, 1])-(Subscript[ℰ, 2]))/ℛ)-(Subscript[ℰ, 3]))/(Subscript[𝒞, 2])), ((Subscript[ℰ, 2])/ℒ), ω (Subscript[ℰ, 5]), -ω (Subscript[ℰ, 4]), (Subscript[ℰ, 1]), (Subscript[ℰ, 2]), (Subscript[ℰ, 3]), (Subscript[ℰ, 4]), (Subscript[ℰ, 5]), \[Null], {}Automatic, ])/. pars1;

The complete system:

sys=SystemsModelMerge[{asys,nsys}]

The poles of the disturbance model:

(Subscript[poles, d])=Eigenvalues@First@Normal@StateSpaceModel[nsys]//N

The system poles consist of the three new poles and the stabilizable poles:

decays=Join[{-1,-2,-3},DeleteCases[%,Complex[_?PossibleZeroQ,_]]]

The regulator:

k=FullInformationOutputRegulator[{sys,All,All,{7,8}},{"Poles",decays}]

The closed-loop system:

csys=SystemsModelStateFeedbackConnect[sys,k]//Simplify

The simulation shows that the regulation is achieved:

OutputResponse[{csys,{10,0,0.1,0,0,0,0,-1}},0,{t,0,10}];
Plot[%,{t,0,10},PlotRange->All]

OpenersExampleSection4(Spacer1)Properties & Relations  (4)

(RefLink[StateFeedbackGains, paclet:ref/StateFeedbackGains]) is a special case:

ssm=(StateSpaceModelFull[2, 0, -1, 1, 1, 0, -2, 1, 0, 1, 1, -1, 1, 1, -1, 1, -1, 0, 0, 0, 0, 1, -1, 0, 0, , , ]);
poles={-1,-2,-3};

FullInformationOutputRegulator[ssm,{"Poles",poles}]

StateFeedbackGains[ssm,poles]

(RefLink[LQRegulatorGains, paclet:ref/LQRegulatorGains]) is a special case:

ssm=(StateSpaceModelFull[2, 0, -1, 1, 1, 0, -2, 1, 0, 1, 1, -1, 1, 1, -1, 1, -1, 0, 0, 0, 0, 1, -1, 0, 0, , , ]);
weights={IdentityMatrix[3],IdentityMatrix[2]};

FullInformationOutputRegulator[N@ssm,{"Weights",weights}]

LQRegulatorGains[N@ssm,weights]

Obtain the closed-loop system using (RefLink[SystemsModelStateFeedbackConnect, paclet:ref/SystemsModelStateFeedbackConnect]):

sys=(NonlinearStateSpaceModelFull[u+w+p x, 0, x, x, w, \[Null], \[Null], {u}Automatic, ]);

SystemsModelStateFeedbackConnect[sys,FullInformationOutputRegulator[sys,{"Poles",{(Subscript[p, f])}}]]

Output regulation is achieved:

sys=(StateSpaceModelFull[2, 0, -1, 1, 1, 1, 0, -2, 1, 0, 0, 1, 1, -1, 1, 0, 1, -1, 0, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, 0, 0, 1, -1, 0, 0, 0, , , ]);

k=FullInformationOutputRegulator[sys,{"Poles",N@{-1,-2,-3}}]

csys=SystemsModelStateFeedbackConnect[sys,k]

OutputResponse[{csys,RandomReal[2,4]},0,{t,0,5}];
Plot[Evaluate[%],{t,0,5},PlotRange->All]

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[StateFeedbackGains, paclet:ref/StateFeedbackGains])  ▪  (RefLink[LQRegulatorGains, paclet:ref/LQRegulatorGains])  ▪  (RefLink[AsymptoticOutputTracker, paclet:ref/AsymptoticOutputTracker])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Nonlinear Control Systems, paclet:guide/NonlinearControlSystems])}})}})