Robust Control Toolbox™

Compute controller for plant G to optimally match target loop shape Gd

Syntax

• [K,CL,GAM,INFO]=loopsyn(G,Gd)
  [K,CL,GAM,INFO]=loopsyn(G,Gd,RANGE) 
  

Description

loopsyn is an H optimal method for loopshaping control synthesis. It computes a stabilizing Hcontroller K for plant G to shape the sigma plot of the loop transfer function GK to have desired loop shape G_d with accuracy =GAM in the sense that if ₀ is the 0db crossover frequency of the sigma plot of G_d(j), then, roughly,

(5-16)

(5-17)

The STRUCT array INFO returns additional design information, including a MIMO stable min-phase shaping pre-filter W, the shaped plant G_s = GW, the controller for the shaped plant K_s=WK, as well as the frequency range {_min,_max} over which the loop shaping is achieved

Input Arguments:
G	LTI Plant
Gd	Desired loop-shape (LTI Model)
RANGE	(optional, default {0,Inf}) Desired frequency range for loop-shaping, a 1-by-2 cell array {min,max}; max should be at least ten times min

.

Output Arguments:
K	LTI controller
CL= G*K/(I+GK)	LTI closed-loop system
GAM	loop-shaping accuracy (GAM 1, with GAM=1 being perfect fit
INFO	additional output information

INFO.W	LTI pre-filter W satisfying (Gd)=(GW) for all ; W is always minimum-phase
INFO.Gs	LTI shaped plant: Gs = GW
INFO.Ks	LTI controller for the shaped plant: Ks=WK
INFO.range	{min,max} cell-array containing the approximate frequency range over which loop-shaping could be accurately achieved to with accuracy G. The output INFO.range is either the same as or a subset of the input range

Algorithm

Using the GCD formula of Le and Safonov [1], loopsyn first computes a stable-minimum-phase loop-shaping, squaring-down prefilter W such that the shaped plant G_s = GW is square, and the desired shape G_d is achieved with good accuracy in the frequency range {_min,_max} by the shaped plant; i.e.,

• (G_d) (G_s) for all {_min,_max}.

Then, loopsyn uses the Glover-McFarlane [2] normalized-coprime-factor control synthesis theory to compute an optimal "loop-shaping" controller for the shaped plant via Ks=ncfsyn(Gs), and returns K=W*Ks.

If the plant G is a continuous time LTI and

1. G has a full-rank D-matrix, and
2. no finite zeros on the j-axis, and
3. {_min,_max}=[0,],

then GW theoretically achieves a perfect accuracy fit (G_d) = (GW) for all frequency . Otherwise, loopsyn uses a bilinear pole-shifting bilinear transform [3] of the form

• Gshifted=bilin(G,-1,'S_Tust',[min,max]),
  

which results in a perfect fit for transformed Gshifted and an approximate fit over the smaller frequency range [_min,_max] for the original unshifted G provided that _max >> _min. For best results, you should choose _max to be at least 100 times greater than _min. In some cases, the computation of the optimal W for Gshifted may be singular or ill-conditioned for the range [_min,_max], as when Gshifted has undamped zeros or, in the continuous-time case only, Gshifted has a D-matrix that is rank-deficient); in such cases, loopsyn automatically reduces the frequency range further, and returns the reduced range [_min,_max] as a cell array in the output INFO.range={_min,_max}

Example

The following code generates the optimal loopsyn loopshaping control for the case of a 5-state, 4-output, 5-input plant with a full-rank non-minimum phase zero at s=+10. The result in shown in Figure 5-11.

• rand('seed',0);randn('seed',0); 
  s=tf('s'); w0=5; Gd=5/s;           % desired bandwith w0=5
  G=((s-10)/(s+100))*rss(3,4,5);     % 4-by-5 non-min-phase plant
  [K,CL,GAM,INFO]=loopsyn(G,Gd);  
  sigma(G*K,'r',Gd*GAM,'k-.',Gd/GAM,'k-.',{.1,100})  % plot result
  

This figure shows that the LOOPSYN controller K optimally fits

• sigma(G*K) = sigma(Gd)±GAM  %  dB
  

In the above example, GAM = 2.0423 = 6.2026 dB.

Figure 5-11: LOOPSYN controller

The loopsyn controller K optimally fits sigma(G*K). As shown in Figure 5-11, it is sandwiched between sigma(Gd/GAM) and sigma(Gd*GAM) in accordance with the inequalities in Equation 5-16 and Equation 5-17. In the this example, GAM = 2.0423 = 6.2026 db.

Limitations

The plant G must be stabilizable and detectable, must have at least as many inputs as outputs, and must be full rank; i.e,

• size(G,2) size(G,1)
• rank(freqresp(G,w)) = size(G,1) for some frequency w.

The order of the controller K can be large. Generically, when G_d is given as a SISO LTI, then the order N_K of the controller K satisfies

N_K = N_Gs + N_W
= N_yN_Gd + N_RHP + N_W
= N_yN_Gd + N_RHP + N_G

where

• N_y denotes the number of outputs of the plant G,
• N_RHP denotes the total number of non-stable poles and non-minimum-phase zeros of the plant G, including those on the stability boundary and at infinity, and
• N_G, N_Gs, N_Gd and N_W denote the respective orders of G, G_s, G_d and W.

Model reduction can help reduce the order of K -- see reduce and ncfmr.

References

[1]  Le, V.X., and M.G. Safonov. Rational matrix GCD's and the design of squaring-down compensators--a state space theory. IEEE Trans. Autom.Control, AC-36(3):384-392, March 1992.

[2]  Glover, K., and D. McFarlane. Robust stabilization of normalized coprime factor plant descriptions with H-bounded uncertainty. IEEE Trans. Autom. Control, AC-34(8):821-830, August 1992.

[3]  Chiang, R.Y., and M.G. Safonov. H synthesis using a bilinear pole-shifting transform. AIAA J. Guidance, Control and Dynamics, 15(5):1111-1115, September-October 1992.

See Also
loopsyn_demo  A demo of this function

mixsyn      H mixed-sensitivity controller synthesis

ncfsyn      H - normailized coprime controller synthesis

ltiarray2uss

Purpose

Computes uncertain system bounding given LTI ss array.

Syntax

• usys = ltiarray2uss(P,Parray,ord) 
  [usys,wt] = ltiarray2uss(P,Parray,ord) 
  [usys,wt,diffdata] = ltiarray2uss(P,Parray,ord) 
  [usys,wt,diffdata] = ltiarray2uss(P,Parray,ord,'InputMult') 
  [usys,wt,diffdata] = ltiarray2uss(P,Parray,ord,'OutputMult') 
  [usys,wt,diffdata] = ltiarray2uss(P,Parray,ord,'Additive') 
  

Description

The command ltiarray2uss, calculates an uncertain system usys with nominal value P, and whose range of behavior includes the given array of systems, Parray.

usys = ltiarray2uss(P,Parray,ord), usys is formulated as an input multiplicative uncertainty model,
usys = P*(I + wt*ultidyn('IMult',[size(P,2) size(P,2)])), where wt is a stable scalar system, whose magnitude overbounds the relative difference, (P - Parray)/P. The state order of the weighting function used to bound the multiplicative difference between P and Parray is ord. Both P and Parray must be in the classes ss/tf/zpk/frd. If P is an frd then usys will be a ufrd object, otherwise usys will be a uss object. The ultidyn atom is named based on the variable name of Parray in the calling workspace.

[usys,wt] = ltiarray2uss(P,Parray,ord), returns the weight wt used to bound the infinity norm of ((P - Parray)/P).

[usys,wt] = ltiarray2uss(P,Parray,ord,'OutputMult'), uses multiplicative uncertainty at the plant output (as opposed to input multiplicative uncertainty). The formula for usys is
usys = (I + wt*ultidyn('Name',[size(P,1) size(P,1)])*P).

[usys,wt] = ltiarray2uss(P,Parray,ord,'Additive'), uses additive uncertainty.
usys = P + wt*ultidyn('Name',[size(P,1) size(P,2)]). wt is a frequency domain overbound of the infinity norm of (Parray - P).

[usys,wt] = ltiarray2uss(P,Parray,ord,'InputMult'), uses multiplicative uncertainty at the plant input (this is the default). The formula for usys is usys = P*(I + wt*ultidyn('Name',[size(P,2) size(P,2)])).

[usys,wt,diffdata] = ltiarray2uss(P,Parray,ord,type) returns the norm of the difference (absolute difference for additive, and relative difference for multiplicative uncertainty) between the nominal model P and Parray. wt satisfies diffdata(w_i) < |wt(w_i)| at all frequency points.

Example

See the Robust Control Toolbox™ demo entitled "First-cut Robust Design" for a more detailed example of how to use ltiarray2uss.

Consider a third order transfer function with an uncertain gain, filter time constant and a lightly damped flexible mode. This model is used to represent a physical system from frequency response data is acquired.

• gain = ureal('gain',10,'Perc',20); 
  tau = ureal('tau',.6,'Range',[.42 .9]); 
  wn = 40; 
  zeta = 0.1; 
  usys = tf(gain,[tau 1])*tf(wn^2,[1 2*zeta*wn wn^2]); 
  sysnom = usys.NominalValue; 
  parray = usample(usys,30); 
  om = logspace(-1,2,80); 
  parrayg = frd(parray,om); 
  bode(parrayg) 
  
  
  
  The frequency response data in parray represents 30 experiments performed on the system. The command ltiarray2uss is used to generate an uncertain model, umod, based on the frequency response data. Initially an input multiplicative uncertain model is used to characterize the collection of 30 frequency responses. First and second order input multiplicative uncertainty weight are calculated from the data. 
  [umodIn1,wtIn1,diffdataIn] = ltiarray2uss(sysnom,parrayg,1); 
  [umodIn2,wtIn2,diffdataIn] = ltiarray2uss(sysnom,parrayg,2); 
  bodemag(wtIn1,'b-',wtIn2,'g+',diffdataIn,'r.',om) 
  
  
  
  Alternatively,  an additive uncertain model is used to characterize the collection of 30 frequency responses. 
  [umodAdd1,wtAdd1,diffdataAdd] = 
  ltiarray2uss(sysnom,parrayg,1,'Additive'); 
  [umodAdd2,wtAdd2,diffdataAdd] = 
  ltiarray2uss(sysnom,parrayg,2,'Additive'); 
  bodemag(wtAdd1,'b-',wtAdd2,'g+',diffdataAdd,'r.',om) 
  
  
  

See Also
fitmagfrd   Fit frequency response magnitude data

Provide feedback about this page

loopsens

ltrsyn

© 1984-2008- The MathWorks, Inc.    -   Site Help   -   Patents   -   Trademarks   -   Privacy Policy   -   Preventing Piracy   -   RSS