Scilab Function

ddp - disturbance decoupling

### Calling Sequence

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

### Parameters

- `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'` .
- `alfa` : 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.
    alfa=-1;beta=-2;flag='ge';
    [X,dims,F,U,k,Z]=abinv(Sys12,alfa,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',alfa,beta);
    closed=syslin('c',A+B2*F,B1+B2*G,C1+D12*F,D11+D12*G);
    ss2tf(closed)

### See Also

`abinv` , `ui_observer` ,

### Author

F.D.