Invarianza di un politopo

1. 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

2. 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
( )

3. 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 ( ) la matrice dei vertici di un generico
politopo .
Il problema consiste nel calcolare (se esiste) tale che ( ) ( ) .
E’ possibile dimostrare che se la condizione precedente è vera per , è vera
sempre. Infatti:

4. 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

5. 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 e .
Chiamiamo 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:

6. ̅ ̅ ̅ ̂
oppure alternativamente
(̅| ̅) ( ) ̅ ̂ ( )
Dalla seconda equazione del sistema (3) andando a trasporre otteniamo:
( )
dove , e
Definendo con 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:
{
̅̅̅ ̅
̅̅̅ ̅
̅̅̅ ̅

7. 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
( | | ) (
̅
)

8. 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.

9. 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);

10. 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 = blkdiag(A_barrato, A);
B_barrato = blkdiag(B_barrato, B);
V_barrato = blkdiag(V_barrato, Q);
V_cappuccio = [V_cappuccio;Q(:,i)];
end
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

11. % 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));