UNIVERSITA' DEGLI STUDI DELL'AQUILA
CORSO DI LAUREA MAGISTRALE IN INGEGNERIA INFORMATICA AUTOMATICA
Esercitazione “Invarianza di un politopo” Studenti: Luca Finocchio mat. 216082 Vittoriano Muttillo mat. 214248
1. INTRODUZIONE Scopo della esercitazione è la realizzazione di un piccolo script MATLAB, che, dati in ingresso due matrici , caratterizzanti un sistema lineare a tempo discreto, e i vertici di un politopo, restituisca una matrice tale che esista una legge di controllo per la quale il politopo risulti tempo invariante per il sistema dinamico a ciclo chiuso oppure una segnalazione di non esistenza della soluzione. Al problema sarà data in primis una soluzione teorica, alla quale, poi, seguirà l’implementazione in MATLAB.
PROBLEMA Dato un sistema lineare a tempo discreto descritto delle seguenti equazioni. (
) ( )
( )
( )
( )
con e e dato un politopo , descritto attraverso i suoi vertici, determinare, se esiste, una legge di controllo ( )
( )
tale che il politopo risulta invariante per il sistema dinamico a ciclo chiuso, cioè tale che (
)
2. SOLUZIONE TEORICA Il sistema preso in considerazione nel testo del problema ( è un sistema lineare a tempo discreto in cui , ( ) .
) ( ) , ( )
( ) e
Esso è soggetto a retroazione di stato ( ) ( ) dove la è la matrice di retroazione dello stato. Il sistema a ciclo chiuso sarà quindi descritto dalla seguente equazione: (
)
( )
( )
(
) ( )
Dalla teoria, ricordiamo che il problema di stabilizzazione via retroazione dello stato è risolubile se la coppia (A, B) è stabilizzabile, cioè se essa è completamente raggiungibile oppure se eventuali autovalori non raggiungibili hanno parte reale negativa. Inoltre è utile sottolineare che “Se il sistema considerato non è stabilizzabile e il politopo ha interno, esso non potrà essere reso invariante (a meno di politopi speciali)” Detto ciò definiamo politopo .
(
Il problema consiste nel calcolare
) la matrice dei vertici di un generico (se esiste) tale che ( )
E’ possibile dimostrare che se la condizione precedente è vera per sempre. Infatti:
( )
. , è vera
Dunque ciò che vogliamo dimostrare è che ( Chiamiamo ̂
(
)
) e riscriviamo il problema nella forma ̂
( )
In generale, sappiamo che ogni punto del politopo può essere scritto come combinazione convessa dei vertici del politopo, cioè , dove , ( ), . Procediamo quindi riscrivendo la condizione (1) in termini di vertici per il politopo: ̂
dove
(
)
( )
( ) entrambe con dimensione
e valgono le seguenti
condizioni: ∑ ∑ Visto che la condizione (2) è vera per tutti i punti del politopo, è certamente vero per ogni vertice. Grazie a questa precisazione possiamo scrivere la condizione (2) per ogni vertice: ̂ dove valgono: ∑ Le condizioni da scrivere son quindi tante quanti sono i vertici del politopo. A questo punto, vogliamo riportare il problema iniziale ad un problema di programmazione lineare, in modo da poter utilizzare la funzione lineprog di
MATLAB. Per far ciò tutte le precedenti equazioni e disequazioni saranno manipolate in modo appropriato, al fine di poter utilizzare la funzione sopracitata. Partiamo da (
Che è un’equazione nelle incognite Chiamiamo
)
e .
ottenendo il seguente sistema: ( )
{
Controlliamo se il sistema (3) è robusto dal punto di vista dimensionale:
⇒
⇒
⇒
Estendendo la prima equazione del sistema (3) per ogni j otteniamo:
{ Riscrivendo il tutto in forma matriciale otteniamo invece: (
)(
)
(
)(
)
(
Che riscritta in forma compatta, assume la seguente forma:
)(
)
̅
̅ ̂
̅
oppure alternativamente ( ̅ | ̅) ( )
̅̂ ( )
Dalla seconda equazione del sistema (3) andando a trasporre otteniamo: ( ) dove
,
Definendo con
e la i-esima colonna di
possiamo scrivere in forma estesa:
( ) ( ) {( ) con
scalare.
Riscrivendo il tutto in forma matriciale otteniamo: ( ) ( )
( ( ))
(
oppure in forma compatta: ̅̅̅ ̅ dove ̅̅̅
,̅
,
Espandendolo ancora solo per elementi si ottiene:
{
̅̅̅ ̅ ̅̅̅ ̅ ̅̅̅ ̅
) (
)
oppure ̅̅̅ ̅̅̅ ( ) ̅
(
)
̅̅̅ In forma compatta ̃̅ ̃̅
( )
Arrivati a questo punto possiamo definire il vettore delle variabili di ottimizzazione: ( ) ̅ e possiamo riportare le equazioni precedenti in termini di z:
dalla (4) segue ( ̅| ̅| ) ( ) ̅
dalla (5) segue ( | Da
⇒
| ̃) ( ) ̅
segue (
| | )( ) ̅
̅̂
Dopo aver definito il vettore ̅
(
) di dimensione
da ∑
segue
( | | )( ) ̅ ̅
̅
(
dove
)
( )
̅ Siamo finalmente giunti al punto nel quale possiamo riformulare in problema iniziale come un problema di programmazione lineare: |
(
|
|
)
s.t. ̅
̅
̅̂
̃)
( (
(
)
|
)
| | )
Definiamo: ̅
̅ ̃ ) come
( ̅̂
(
) come
(
| | ) come
,
come
E riscriviamo il problema come: (
|
| s.t.
3. IMPLEMETAZIONE SCRIPT Di seguito sono riportati il codice relativo allo script ed il relativo output. Per l’esempio sono state usate le seguenti matrici:
(
(
(
) ) )
e come politopo è stato scelto un rombo centrato nell’origine degli assi.
3.1 CODICE clear all; close all; clc; %es1 %A = [2 0; 2 -1]; %B = [1 1 ; 1 1]; %Q = [[1;0] [0;1] [-1;0] [0;-1]]; %x0=[0;0.5]; %es2 A = [-0.5 0; 3 -0.7]; B = [1 1 ; 1 0]; Q = [[-1;-1] [-2;0] [-1;1] [1;1] [2;0] [1;-1]]; x0=[0;0.5]; %es.3 %A = [-1 -2; 0 -1]; %B = [1; 1]; %Q = [[-1;-1] [-1;1] [1;1] [1;-1]]; %x0=[0;0.4]; % Definizione delle matrici che caratterizzano il sistema disp('La matrice A è: '); disp(A); n = size(A,1); disp('La matrice B è: '); disp(B); m = size(B,2); C = [1 1]; % Definizione del politopo tramite i suoi vertici % In questo esempio verrà scelto un rombo r = size(Q,2); % Calcoliamo gli autovalori della matrice A per vedere se il sistema è % asintoticamente stabile av_A = eig(A);
disp('Gli autovalori di A sono: '); disp(av_A); if sum(abs(av_A)<1) == length(av_A) disp('Il sistema è asintoticamente stabile') ; disp(' '); else disp('Il sistema non è asintoticamente stabile'); disp(' '); end % Controlliamo ora la controllabilità del sistema S = ctrb(A,B); rs = rank(S); if rs == n disp('Il sistema è controllabile'); disp(' '); else disp('Il sistema non è controllabile'); disp(' '); [Abar,Bbar,Cbar,T,k] = ctrbf(A,B,C); NC = Abar(1:n-rs, 1:n-rs); av_NC = eig(NC); av_A = eig(A); if sum(abs(av_NC)<1) == length(av_NC) disp('ma è stabilizzabile'); disp(' '); else disp('e non è stabilizzabile'); disp(' '); end end % Calcoliamo le matrici necessarie alla risoluzione del problema di % programmazione lineare A_barrato = []; B_barrato = []; V_barrato = []; V_cappuccio = []; V_tilde = []; V_trasp = cell(1,r); K = []; uno_segnato = ones(1,r); b = uno_segnato'; for i=1:r A_barrato = B_barrato = V_barrato = V_cappuccio end
blkdiag(A_barrato, A); blkdiag(B_barrato, B); blkdiag(V_barrato, Q); = [V_cappuccio;Q(:,i)];
for i=1:r for j=1:m V_trasp{i} = blkdiag(V_trasp{i},Q(:,i)'); end V_tilde = [V_tilde; V_trasp{i}]; end for i=1:r K = blkdiag(K, uno_segnato); end
% Calcoliamo le matrici che controllano le condizioni di uguaglianza e % disuguaglianza del problema di programmazione lineare Aeq = [-V_barrato B_barrato zeros(size(V_barrato,1),size(V_tilde,2)); zeros(size(V_tilde,1),size(V_barrato,2)) -eye(r*m) V_tilde; K zeros(r,r*m) zeros(r,n*m)]; beq = [-A_barrato*V_cappuccio; zeros(r*m,1); b]; Adiseq = [-eye(r^2) zeros(r^2,r*m) zeros(r^2,n*m)]; bdiseq = zeros(r^2,1); f = [zeros(1,r^2) zeros(1,r*m) ones(1,n*m)]';
% Calcoliamo la soluzione al problema di programmazione lineare [z,fval,exitflag] = linprog(f, Adiseq, bdiseq, Aeq, beq); % Estraiamo F dalla soluzione F = []; F_tmp = z(r^2+r*m+1:end); if m == 1 F = F_tmp'; else for i=1:n:n*m F = [F;F_tmp(i:i+n-1,1)']; end end disp(' '); disp('La matrice di retroazione dello stato F è: '); disp(F); disp('Gli autovalori della matrice A+BF sono: '); disp(eig(A+B*F)); x=[Q(1:n:r*n) Q(1)]; y=[Q(2:n:r*n) Q(2)];
N=30; xk=x0; for i=1:N xk_tmp(i,:) = xk'; xk = (A+(B*F))*xk; end plot(x,y,xk_tmp(:,1),xk_tmp(:,2));