Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Scilab-Branch-6.1-GIT
Change language to: Français - Português - 日本語 - Русский

augment

augmented plant

Syntax

[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'  (K*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 = blockdiag(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))