Robust Control Toolbox™

Decompose uncertain objects into fixed normalized and fixed uncertain parts

Syntax

• [M,Delta] = lftdata(A); 
  [M,Delta] = lftdata(A,List); 
  [M,Delta,Blkstruct] = lftdata(A);
  [M,Delta,Blkstruct,Normunc] = lftdata(A); 
  

Description

lftdata decomposes an uncertain object into a fixed certain part and a normalized uncertain part. lftdata can also partially decompose an uncertain object into an uncertain part and a normalized uncertain part. Uncertain objects (umat, ufrd, uss) are represented as certain (i.e., not-uncertain) objects in feedback with block-diagonal concatenations of uncertain elements.

[M,Delta] = lftdata(A) separates the uncertain object A into a certain object M and a normalized uncertain matrix Delta such that A is equal to lft(Delta,M), as shown below.

If A is a umat, then M will be double; if A is a uss, then M will be ss; if A is a ufrd, then M will be frd. In all cases, Delta is a umat.

[M,Delta] = lftdata(A,List) separates the uncertain object A into an uncertain object M, in feedback with a normalized uncertain matrix Delta. List is a cell (or char) array of names of uncertain elements of A that make up Delta. All other uncertainty in A remains in M.

lftdata(A,fieldnames(A.Uncertainty)) is the same as lftdata(A).

[M,DELTA,BLKSTRUCT] = lftdata(A) returns an N-by-1 structure array BLKSTRUCT, where BLKSTRUCT(i) describes the i-th normalized uncertain element. This uncertainty description can be passed directly to the low-level structured singular value analysis function mussv.

[M,DELTA,BLKSTRUCT,NORMUNC] = lftdata(A) returns the cell array NORMUNC of normalized uncertain elements. Each normalized element has the string 'Normalized' appended to its original name to avoid confusion. Note that lft(blkdiag(NORMUNC{:}),M) is equivalent to A.

Example

Create an uncertain matrix A with 3 uncertain parameters p1, p2 and p3. You can decompose A into its certain, M, and normalized uncertain parts, Delta.

• p1 = ureal('p1',-3,'perc',40); 
  p2 = ucomplex('p2',2); 
  A = [p1 p1+p2;1 p2]; 
  [M,Delta] = lftdata(A); 
  

You can inspect the difference between the original uncertain matrix, A, and the result formed by combining the two results from the decomposition.

• simplify(A-lft(Delta,M)) 
  ans = 
       0     0 
       0     0 
  M 
  M = 
           0         0    1.0954    1.0954 
           0         0         0    1.0000 
      1.0954    1.0000   -3.0000   -1.0000 
           0    1.0000    1.0000    2.0000 
  

You can check the worst-case norm of the uncertain part using wcnorm. Compare samples of the uncertain part A with the uncertain matrix A.

• wcn = wcnorm(Delta) 
  wcn = 
      lbound: 1.0000 
      ubound: 1.0001 
  usample(Delta,5) 
  ans(:,:,1) = 
     0.8012                  0          
          0             0.2499 + 0.6946i 
  ans(:,:,2) = 
     0.4919                  0          
          0             0.2863 + 0.6033i 
  ans(:,:,3) = 
    -0.1040                  0          
          0             0.7322 - 0.3752i 
  ans(:,:,4) = 
     0.8296                  0          
          0             0.6831 + 0.1124i 
  ans(:,:,5) = 
     0.6886                  0          
          0             0.0838 + 0.3562i 
  

Uncertain Systems

Create an uncertain matrix A with 2 uncertain real parameters v1 and v2 and create an uncertain system G using A as the dynamic matrix and simple matrices for the input and output.

• A = [ureal('p1',-3,'perc',40) 1;1 ureal('p2',-2)]; 
  sys = ss(A,[1;0],[0 1],0);
  sys.InputGroup.ActualIn = 1; 
  sys.OutputGroup.ActualOut = 1; 
  

You can decompose G into a certain system, Msys, and a normalized uncertain matrix, Delta. You can see from Msys that it is certain and that the input and output groups have been adjusted.

• [Msys,Delta] = lftdata(sys); 
  Msys 
  
  a = 
         x1  x2 
     x1  -3   1 
     x2   1  -2 
  
  
  b = 
            u1     u2     u3 
     x1  1.095      0      1 
     x2      0      1      0 
  
  
  c = 
            x1     x2 
     y1  1.095      0 
     y2      0      1 
     y3      0      1 
  
  
  d = 
         u1  u2  u3 
     y1   0   0   0 
     y2   0   0   0 
     y3   0   0   0 
  
  Input groups:            
        Name      Channels 
      ActualIn       3     
       p1_NC         1     
       p2_NC         2     
                           
  Output groups:           
        Name       Channels 
      ActualOut       3    
        p1_NC         1    
        p2_NC         2    
                           
  Continuous-time model. 
  

You can compute the norm on samples of the difference between the original uncertain matrix and the result formed by combining Msys and Delta.

• norm(usample(sys-lft(Delta,Msys),'p1',4,'p2',3),'inf') 
  ans = 
       0     0     0 
       0     0     0 
       0     0     0 
       0     0     0 
  

Partial Decomposition

Create an uncertain matrix A and derive an uncertain matrix B using an implicit-to-explicit conversion, imp2exp. Note that B has 2 uncertain parameters R and K. You can decompose B into certain, M, and normalized uncertain parts, Delta.

• R = ureal('R',1,'Percentage',[-10 40]); 
  K = ureal('K',2e-3,'Percentage',[-30 30]); 
  A = [1 -R 0 -K;0 -K 1 0]; 
  Yidx = [1 3]; 
  Uidx = [4 2]; 
  B = imp2exp(A,Yidx,Uidx); 
  [M,Delta] = lftdata(B); 
  

The same operation can be performed by defining the uncertain parameters, K and R, to be extracted.

• [MK,DeltaR] = lftdata(B,'R'); 
  MK 
  UMAT: 3 Rows, 3 Columns 
    K: real, nominal = 0.002, variability = [-30  30]%, 2 occurrences 
  [MR,DeltaK] = lftdata(B,'K'); 
  MR 
  UMAT: 4 Rows, 4 Columns 
    R: real, nominal = 1, variability = [-10  40]%, 1 occurrence 
  
  simplify(B-lft(Delta,M)) 
  ans = 
       0     0 
       0     0 
  simplify(B-lft(DeltaR,MK)) 
  ans = 
       0     0 
       0     0 
  simplify(B-lft(DeltaK,MR)) 
  ans = 
       0     0 
       0     0 
  

Sample and inspect the uncertain part as well as the difference between the original uncertain matrix and the sampled matrix. You can see the result formed by combining the two results from the decomposition.

• [Mall,Deltaall] = lftdata(B,{'K';'R'}); 
  simplify(Mall)-M 
  ans = 
       0     0     0     0     0 
       0     0     0     0     0 
       0     0     0     0     0 
       0     0     0     0     0 
       0     0     0     0     0 
  

See Also
lft         Forms Redheffer star product of systems

ssdata      Returns uncertain state-space data

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

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   Fits frequency response with state-space model

ultidyn     Creates an uncertain linear time-invariant object

uss         Creates an uncertain state-space system

Provide feedback about this page

isuncertain

lmiedit

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