augment
=======

augmented plant



Calling Sequence
~~~~~~~~~~~~~~~~


::

    [P,r]=augment(G)
    [P,r]=augment(G,flag1)
    [P,r]=augment(G,flag1,flag2)




Arguments
~~~~~~~~~

:G linear system ( `syslin` list), the nominal plant
: :flag1 one of the following (upper case) character string: `'S'`,
  `'R'`, `'T'` `'SR'`, `'ST'`, `'RT'` `'SRT'`
: :flag2 one of the following character string: `'o'` (stands for
  'output', this is the default value) or `'i'` (stands for 'input').
: :P linear system ( `syslin` list), the ``augmented'' plant
: :r 1x2 row vector, dimension of `P22 = G`
:



Description
~~~~~~~~~~~

If `flag1='SRT'` (default value), returns the "full" augmented plant


::

    [ I | -G]   -->'S'
    [ 0 |  I]   -->'R'
    P = [ 0 |  G]   -->'T'
    [-------]
    [ I | -G]


`'S'`, `'R'`, `'T'` refer to the first three (block) rows of `P`
respectively.

If one of these letters is absent in `flag1`, the corresponding row in
`P` is missing.

If `G` is given in state-space form, the returned `P` is minimal. `P`
is calculated by: `[I,0,0;0,I,0;-I,0,I;I,0,0]*[I,-G;0,I;I,0]`.

The augmented plant associated with input sensitivity functions,
namely


::

    [ I | -I]   -->'S'  (`input`_ sensitivity)
    [ G | -G]   -->'R'  (G*`input`_ sensitivity)
    P = [ 0 |  I]   -->'T'  (K*G*`input`_ sensitivity)
    [-------]
    [ G | -G]


is obtained by the command `[P,r]=augment(G,flag,'i')`. For state-
space `G`, this `P` is calculated by:
`[I,-I;0,0;0,I;0,0]+[0;I;0;I]*G*[I,-I]` and is thus generically
minimal.

Note that weighting functions can be introduced by left-multiplying
`P` by a diagonal system of appropriate dimension, e.g., `P =
sysdiag(W1,W2,W3,eye(G))*P`.

Sensitivity functions can be calculated by `lft`. One has:

For output sensitivity functions [P,r]=augment(P,'SRT'):
lft(P,r,K)=[inv(eye()+G*K);K*inv(eye()+G*K);G*K*inv(eye()+G*K)];

For input sensitivity functions [P,r]=augment(P,'SRT','i'):
lft(P,r,K)=[inv(eye()+K*G);G*inv(eye()+K*G);K*G*inv(eye()+G*K)];



Examples
~~~~~~~~


::

    G=`ssrand`_(2,3,2); //Plant
    K=`ssrand`_(3,2,2); //Compensator
    [P,r]=augment(G,'T');
    T=`lft`_(P,r,K);   //Complementary sensitivity function
    Ktf=`ss2tf`_(K);Gtf=`ss2tf`_(G);
    Ttf=`ss2tf`_(T);T11=Ttf(1,1);
    Oloop=Gtf*Ktf;
    Tn=Oloop*`inv`_(`eye`_(Oloop)+Oloop);
    `clean`_(T11-Tn(1,1));
    //
    [Pi,r]=augment(G,'T','i');
    T1=`lft`_(Pi,r,K);T1tf=`ss2tf`_(T1); //Input Complementary sensitivity function
    Oloop=Ktf*Gtf;
    T1n=Oloop*`inv`_(`eye`_(Oloop)+Oloop);
    `clean`_(T1tf(1,1)-T1n(1,1))




See Also
~~~~~~~~


+ `lft`_ linear fractional transformation
+ `sensi`_ sensitivity functions


.. _sensi: sensi.html
.. _lft: lft.html