ddp
===

disturbance decoupling



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


::

    [Closed,F,G]=ddp(Sys,zeroed,B1,D1)
    [Closed,F,G]=ddp(Sys,zeroed,B1,D1,flag,alfa,beta)




Arguments
~~~~~~~~~

:Sys `syslin` list containing the matrices `(A,B2,C,D2)`.
: :zeroed integer vector, indices of outputs of `Sys` which are
  zeroed.
: :B1 real matrix
: :D1 real matrix. `B1` and `D1` have the same number of columns.
: :flag string `'ge'` or `'st'` (default) or `'pp'`.
: :alpha real or complex vector (loc. of closed loop poles)
: :beta real or complex vector (loc. of closed loop poles)
:



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

Exact disturbance decoupling (output nulling algorithm). Given a
linear system, and a subset of outputs, z, which are to be zeroed,
characterize the inputs w of Sys such that the transfer function from
w to z is zero. `Sys` is a linear system {A,B2,C,D2} with one input
and two outputs ( i.e. Sys: u-->(z,y) ), part the following system
defined from `Sys` and `B1,D1`:


::

    xdot =  A x + B1  w + B2  u
       z = C1 x + D11 w + D12 u
       y = C2 x + D21 w + D22 u


outputs of Sys are partitioned into (z,y) where z is to be zeroed,
i.e. the matrices C and D2 are:


::

    C=[C1;C2]         D2=[D12;D22]
    C1=C(zeroed,:)    D12=D2(zeroed,:)


The matrix `D1` is partitioned similarly as `D1=[D11;D21]` with
`D11=D1(zeroed,:)`. The control is u=Fx+Gw and one looks for matriced
`F,G` such that the closed loop system: w-->z given by


::

    xdot= (A+B2*F)  x + (B1 + B2*G) w
      z = (C1+D12F) x + (D11+D12*G) w


has zero transfer transfer function.

`flag='ge'`no stability constraints. `flag='st'` : look for stable
closed loop system (A+B2*F stable). `flag='pp'` : eigenvalues of
A+B2*F are assigned to `alfa` and `beta`.

Closed is a realization of the `w-->y` closed loop system


::

    xdot= (A+B2*F)  x + (B1 + B2*G) w
      y = (C2+D22*F) x + (D21+D22*G) w


Stability (resp. pole placement) requires stabilizability (resp.
controllability) of (A,B2).



Examples
~~~~~~~~


::

    `rand`_('seed',0);nx=6;nz=3;nu=2;ny=1;
    A=`diag`_(1:6);A(2,2)=-7;A(5,5)=-9;B2=[1,2;0,3;0,4;0,5;0,0;0,0];
    C1=[`zeros`_(nz,nz),`eye`_(nz,nz)];D12=[0,1;0,2;0,3];
    Sys12=`syslin`_('c',A,B2,C1,D12);
    C=[C1;`rand`_(ny,nx)];D2=[D12;`rand`_(ny,`size`_(D12,2))];
    Sys=`syslin`_('c',A,B2,C,D2);
    [A,B2,C1,D12]=`abcd`_(Sys12);  //The matrices of Sys12.
    my_alpha=-1;my_beta=-2;flag='ge';
    [X,dims,F,U,k,Z]=`abinv`_(Sys12,my_alpha,my_beta,flag);
    `clean`_(X'*(A+B2*F)*X)
    `clean`_(X'*B2*U)
    `clean`_((C1+D12*F)*X)
    `clean`_(D12*U);
    //Calculating an ad-hoc B1,D1
    G1=`rand`_(`size`_(B2,2),3);
    B1=-B2*G1;
    D11=-D12*G1;
    D1=[D11;`rand`_(ny,`size`_(B1,2))];
    
    [Closed,F,G]=ddp(Sys,1:nz,B1,D1,'st',my_alpha,my_beta);
    closed=`syslin`_('c',A+B2*F,B1+B2*G,C1+D12*F,D11+D12*G);
    `ss2tf`_(closed)




See Also
~~~~~~~~


+ `abinv`_ AB invariant subspace
+ `ui_observer`_ unknown input observer


.. _ui_observer: ui_observer.html
.. _abinv: abinv.html