Tratto da: “Progetto di un osservatore ∞ per la stima di

temperature e concentrazioni in un reattore batch”

Tutorial descrittivo degli algoritmi sviluppati nel lavoro di tesi in Matlab e simulati
con Simunlink da Massimo Talia presso l’Università degli Studi Mediterranea di
Reggio Calabria- 13/12/2005

16/9/2017
Sommario

Introduzione .................................................................................................................................. 2
Sistemi con non linearità esponenziali e algoritmo numerico di linearizzazione di un reattore
batch. ............................................................................................................................................. 3
Sintesi dell’osservatore e problema H∞ ......................................................................................... 9
Soluzione del problema a 4 parametri e sintesi del problema H∞ .............................................. 13
Introduzione

Questo tutorial nasce allo scopo di illustrare in maniera dettagliata dal punto di vista
implementativo e numerico la tesi di laurea del candidato Massimo Talia e dare la
possibilità, anche a chi non è del settore, di potere apprezzare e conoscere le tecniche
di progettazione soft-computing attraverso l’utilizzo di linguaggi di modellazione
numerica come il Matlab/Simunlink di Mathworks. Nel lavoro di tesi è stato omesso il
codice utilizzato per il progetto, che è stato consegnato su files digitali, per questioni di
riservatezza alla ricerca dei relatori di tesi, che stavano scrivendo gli articoli
scientifici da pubblicare. Ormai sono passati molti anni da allora, le pubblicazioni sono
state portate a termine nel 2008, quindi è possibile rendere noto l’approccio
algoritmico usato per la risoluzione del problema di sintesi dell’osservatore H∞, che
permette di abbattere sensibilmente l’incertezza di misura sulle concentrazioni di
reagenti e sulle temperature interne di un reattore esotermo attraverso l’osservazione
degli stati fisici interni a partire dalle variabili di uscita del sistema, senza operare
trasformazioni fisiche sulla struttura interna del reattore o aggiungendo altri sensori
di misura interni, che garantiscano una maggiore accuratezza nella misura. L’utilizzo
di ulteriore sensoristica interna comporta ridondanza hardware e costi maggiori.
L’osservatore non lineare alla Luenberger H∞, con termini più semplici, non è altro che
un filtro hardware non lineare, che ridondando le dinamiche note del sistema
impianto, permette ad un più basto costo computazionale e monetario, occupando
meno spazio, di effettuare le misurazioni di variabili fisiche soggette ad errore di
misura inferiore all’unità in modulo |e|<1. Il modello in scala di un impianto, replica
le dinamiche di un impianto a dimensioni reali, che viene controllato tipicamente da
sistemi informatici industriali PLC e SCADA, in cui è presente la sensoristica ed
elettronica di supporto necessaria allo scopo di gestire l’impianto, dove le variabili
interne vengono misurate attraverso schede elettroniche embedded, basate su logica a
microprocessore. Il tutorial parte dal codice Matlab e viene spiegato passo per passo e
si parte dalla rappresentazione numerica ISU del reattore con i dati forniti
dall’Università della Basilicata per poi descrivere l’algoritmo di linearizzazione, il
problema di ottimizzazione con l’uso di LMI (Linear Matrix Inequality). Per gli
argomenti trattati si richiede almeno la conoscenza dell’algebra lineare, della
programmazione matematica e ricerca operativa, della programmazione Matlab e
Simunlink.
Sistemi con non linearità esponenziali e algoritmo numerico di
linearizzazione di un reattore batch.
Il problema principale dei sistemi che contengono termini esponenziali o non linearità
in genere è il fatto di non potere applicare le tecniche di sintesi di controllori o
osservatori che valgono per sistemi SISO e MIMO lineari. Esistono pertanto due
strade:

 utilizzare tecniche di sintesi non lineare basate sulla geometria differenziale,

sulle varietà o con schemi adattativi;
 alternativamente andare a scrivere degli algoritmi che rendano il problema
convesso e quindi con una soluzione esprimibile numericamente in forma chiusa
lineare ovvero LPV (lineare parametro variante).

A tal proposito consideriamo il caso del reattore batch, oggetto della discussione di tesi
del candidato Massimo Talia. L’algoritmo consiste nei seguenti passi:

 Definizione di uno sviluppo parabolico per le due cinetiche di reazione

dipendenti dall’uscita del sistema y1 ki(y1) con i=1,2 arrestato al 2° ordine;
 interpolazione dei termini parabola degli esponenziali mediante problema ai
minimi quadrati di tipo pseudo-inversa minima sinistra;
 approssimazione convessa del termine di secondo grado mediante il metodo
politopico (un politopo è un poliedro convesso n dimensionale che ricopre il
dominio del problema).

Numericamente si ha quello che segue. Innanzitutto si parte con la rappresentazione

ISU (Ingresso Stato Uscita) del modello dell’impianto batch in formato numerico:
%Dati sperimentali forniti dall'Università della Basilicata e rappresentazione
ISU del modello del reattore e matrice dell’osservatore ottenuto mediante schema
adattativo.
Ca=[950,939.4303827,906.4231596,874.0894258,820.9254636,187.0305098,37.09954321,
...
29.92687851 ,26.3258357,22.39765897];
Cb=[50,60.56055838,93.49368478,125.6660744,178.3049911,731.3711169,756.3167217,
...
751.6589351,750.0443871,749.5524287];
Tr=[ 293.15,300,310,315,320,329.02,325,320,315,308.15];
Tj=[310,326.7158826,335.8491054,338.4149386,337.0468731,325.2849698,313.4909946,
...
306.4442608, 303.835378, 307.1230027];
Tj_in=[343.1236791,333.4431732,338.3832916,337.8022287,343.1529009,325.526856,30
8.2797938, ...
302.6075331,303.8718612,306.9700997];
%Energie di attivazione Ea1, Ea2 [j/mol]
Ea1=74.781*10^3;
Ea2=124.785*10^3;

%costanti cinetiche k01,k02 [min^-1]

k01=5.35*10^10;
k02=4.61*10^17;
%universale dei gas [j/mol*K]
R=8.31;
%Prodotto coefficiente di trasferimento del calore(U)
%(S)sezione del di trasferimento del calore [j/min*K].
US=2052*10^3;
%Flusso di fluido refrigerante [m^3/min].
F=3.5;
%Volume jacket [m^3].
Vj=1.8;
%Volume del reattore [m^3].
Vr=6;
%entalpie [j/mol].
deltaH1=-79.2*10^3;
deltaH2=-53.0*10^3;
%Prodotto densità di fluido nel reattore(Ror)
%(Cpr)capacità di emissione calore della massa dei reagenti
%nel reattore [j/m^3*K].
RorCpr=4.19*10^6;
%Prodotto della densità del fluido nel jacket(Roj)
%(Cpj) capacità della massa di fluido nel jacket [j/m^3*K].
RojCpj=4.19*10^6;
betaj=F/Vj;
%coefficienti alfai con i=1,2 e alfastar con star=r,j
alfa1=-deltaH1/RorCpr;
alfa2=-deltaH2/RorCpr;
alfar=1/(Vr*RorCpr);
alfaj=1/(Vj*RojCpj);
%Matrice Osservatore adattativo tratto dall’articolo scientifico fornito
all’università
Lstar=[10^3 0;6*10^3 0;50 0;0 40]

Successivamente si fissano i valori del tempo di evoluzione della reazione che è di circa
90 min e il valore degli stati iniziali e delle incertezze che inficiano sull’impianto.

%tempo
tempo=0:.01:90;
%vettore degli stati iniziali.
x0=[Ca(1) Cb(1) Tr(1) Tj(1)];
%Interpolazione di 900 campioni
Tj_in_new=interp(Tj_in,900);
%Vettore degli ingressi interpolati from workspace
v=[tempo(1:end-1)' Tj_in_new'];
%Incertezza sulle Concentrazioni Ca, Cb pari al 5 percento
deltaCa=Ca(1)*0.05;
deltaCb=Cb(1)*0.05;
%Condizioni iniziali perturbate dall'incertezza
x0_tilde=[x0(1)+deltaCa,x0(2)+deltaCb,x0(3),x0(4)];
%Incertezza sul prodotto US pari al 35 percento
deltaUS=0.35*US;
%Scostamento di US dovuto all'incertezza
US_new=US+deltaUS;
%Varianza
varianza=10^-3;
Si approssimano le due cinetiche di reazione k1, k2 con due sviluppi di Taylor arrestati
al secondo ordine con il resto di Lagrange su una temperatura che varia da 293 °K a
329 °K con un passo di 3.7 °K:
%Attraverso un problema di ottimizzazione vincolata di tipo minimi quadrati
%-----------------min e e'*Q*e---------------------------------------------
%-----------------s.a G*x=b-e----------------------------------------------
%otteniamo la stima delle curve di tipo lineare che meglio approssimano le
%due esponenziali k1(Tr) e k2(Tr).
%Approssimiamo con una funzione parabola ki(Tr)=ai+bi*Tr(j))+ci*Tr(j)^2+res,
%i=1,2 j=1...10 dove res è lo scostamento tra ki(Tr) e ki(Tr)cap le esponenziali
%Costruisco una griglia di temperatura approssimante con 10 campioni di Tr
Tr1=293:3.7:329;
for i=1:length(Tr1)
k_1(i)=k01*exp(-Ea1/(R*Tr1(i)));
k_2(i)=k02*exp(-Ea2/(R*Tr1(i)));
end
for i=1:length(Tr1)

G(i,:)=[1 Tr1(i) Tr1(i)^2;];

end
% %Vettore dei valori reali per k1(Tr)
b1=k_1';
% %Vettore dei valori reali per k2(Tr)
b2=k_2';

Si interpolano le due cinetiche di reazione k1, k2 attraverso un problema ai minimi

quadrati di tipo pseudo inversa minima sinistra, in modo da ottenere una
rappresentazione approssimata polinomiale dell’esponenziale fino al secondo ordine:

%Matrice della forma quadratica da minimizzare nel problema dei minimi

%quadrati
Q=eye(10);
%Ricavo la pseudo inversa minima sinistra
Flm=inv(G'*Q*G)*G'*Q
%soluzione per k1
disp('Vettore dei minimi quadrati per k1')
y1=Flm*b1
%soluzione per k2
disp('Vettore dei minimi quadrati per k2')
y2=Flm*b2

%Errori e1, e2 ottenuti dalla differenza tra i valori reali delle cinetiche k1,
k2 ottenuti per iterazione sull’intervallo di temperature definite
precedentemente e quelli approssimati ottenuti dal problema di pseudo inversa
minima sinistra ai minimi quadrati y1 ed y2 e sviluppati al secondo ordine
k_1cap(i)e k_2cap(i) sull’intervallo di temperature Tr1:

for i=1:length(Tr1);
k_1cap(i)=y1(1)+y1(2)*Tr1(i)+y1(3)*Tr1(i)^2;
k_2cap(i)=y2(1)+y2(2)*Tr1(i)+y2(3)*Tr1(i)^2;
end
%Definisco l'errore per k1 e per k2
e1=b1-k_1cap'
e2=b2-k_2cap'
%I valori ottenuti dalla differenza tra i vettori dello sviluppo di Taylor
arrestato al 2° ordine delle cinetiche di reazione k1,k2 e le cinetiche
approssimate ottenute dall’interpolazione attraverso problemi dei minimi
quadrati.

e1 =[-0.00175297363541,0.00041470984041,0.00142357928266,
0.00145829007421,0.00076603342336,-0.00032492016742,-0.00138197034534...
-0.00183924238486, -0.00096180181326,0.00219829578479];
e2=[-3.194252667693900e-004,5.479352443885000e-005, 2.507054652797900e-
004,2.829478957726200e-004,1.765975132461400e-004,-2.597649941352000e-005...
-2.541390840012000e-004,-3.916411495149300e-004,-2.495284277302900e-
004,4.756660324115900e-004];

%Determino i range massimi e minimi di variabilità per l'errore di k1 e k2

%Definisco i vettori degli estremi massimi e minimi per ogni parametro. I
parametri in quesitione sono 5 e sono Tr, Tj, res1, res2, delta.

Tr_mm=[min(Tr),max(Tr)];
Tj_mm=[min(Tj),max(Tj)];
res_mm1=[min(e1) max(e1)];
res_mm2=[min(e2) max(e2)];
delta=[0 1];
%Costanti cinetiche massime e minime
k1_min=0.0018;
k1_max=1.4646;
k2_min=1.4999e-5;
k2_max=1.0917;

Si approssima il dominio del problema con un ricoprimento politopico multi affine del
termine quadratico dello sviluppo delle cinetiche di reazione, che nell’algoritmo
originale della tesi viene valutato su 5 parametri e 2 indici (25=32 matrici o vertici del
politopo) Tr, Tj, Res1, Res2, δ (delta), ma che in realtà può essere ridotto a 4 parametri
e 2 indici (24=16 matrici o vertici del politopo) parametri Tr, Tj, ricavando il vettore dei
residui come res_mm=[min(min(e1),min(e2)) max(max(e1),max(e2))], δ(delta). I
risultati sulle simulazioni sono analoghi. Adesso mostriamo il codice a 5 parametri,
successivamente mostriamo quello a 4. La funzione multi affine è costruita al seguente
modo nel caso di 5 parametri e per il termine parabola f(p)=p2 si esprime come
, = , × 0,1 → ℝ.

%--------------------------------------------------------------------------
%Funzione per il calcolo della funzione multiaffine di
%ricoprimento politopico per il termine parabola f(p)=p^2 multiaffine1.m
%--------------------------------------------------------------------------
function f=multiaffine1(xr,xj,res1,res2,delta)
%p è il parametro incerto, delta è un parametro compreso tra [0,1]

Tr=[ 293.15,300,310,315,320,329.02,325,320,315,308.15];
Tj=[310,326.7158826,335.8491054,338.4149386,337.0468731,325.2849698,313.4909946,
...
306.4442608, 303.835378, 307.1230027];
e1 =[-0.00175297363541,0.00041470984041,0.00142357928266,
0.00145829007421,0.00076603342336,-0.00032492016742,-0.00138197034534...
-0.00183924238486, -0.00096180181326,0.00219829578479];
e2=[-3.194252667693900e-004,5.479352443885000e-005, 2.507054652797900e-
004,2.829478957726200e-004,1.765975132461400e-004,-2.597649941352000e-005...
-2.541390840012000e-004,-3.916411495149300e-004,-2.495284277302900e-
004,4.756660324115900e-004];
xrmax= max(Tr);
xrmin=min(Tr);
xjmax=max(Tj);
xjmin=min(Tj);
res1max=max(e1);
res1min=min(e1);
res2max=max(e2);
res2min=min(e1);
%Vettori di componenti massime e minime.
pmax=[xrmax xjmax res1max res2max];
pmin=[xrmin xjmin res1min res2min];
p=[xr xj res1 res2];
for i=1:4
if p(i)>pmax(i)|p(i)<pmin(i)
error('sei fuori dagli intervalli dei valori ammissibili')
end
end
if delta<0|delta>1
error('sei fuori dagli intervalli ammissibili')
end
%Scrivo le funzioni approssimanti la parabola e la funzione multi affine
for i=1:4
f1(i)=(pmin(i))^2+(2*pmin(i)*(p(i)-pmin(i)));
f2(i)=(((pmax(i)+pmin(i))*p(i))-(pmin(i)*pmax(i)));
end
f_low=sum(f1);
f_up=sum(f2);
f=(delta*f_low)+((1-delta)*f_up);

La funzione multi affine del termine quadratico permette di proiettare il termine

quadratico delle cinetiche di reazione su un sottospazio di parametri lineari in
funzione di matrici parametrico lineari dipendenti da Tr, Tj, res1, res2, δ (delta) e di
rendere il problema convesso. Per il teorema di dualità il problema H∞ viene
formulato e risolto sulla dinamica dell’errore.

% Uso il ricoprimento politopico in modo tale da rendere il problema

% convesso.
%Inizializzo un contatore
cont=0;
%Costruisco i cicli for innestati
for i=1:2 %per Tr
for j=1:2 %per Tj
for k=1:2 %per res1
for l=1:2 %per res2
for m=1:2%per delta
cont=cont+1;
%Calcolo i vertici attraverso la funzione multi affine del file multiaffine1.m
per la parabola Tr^2=F(Tr,Tj,res1,res2,delta).
ma(cont)=multiaffine1(Tr_mm(i),Tj_mm(j),res_mm1(k),res_mm2(l),delta(m));
%--------------------------------------------------------------------------
%-------------------Scrivo il sistema in forma Hinf------------------------
%-----------epunto=A1,i(pi)*e+B1(pi)*ew+B2(pi)*eu--------------------------
%-----------ez=C1(pi)*e+D11(pi)*ew+D12(pi)*eu------------------------------
%-----------ey=C2(pi)*e+D21(pi)*ew+D22(pi)*eu------------------------------
%--------------------------------------------------------------------------
%Parabola a cui è stato sostituito il suo sviluppo politopico

k1=y1(1)+(y1(2)*Tr_mm(i))+(y1(3)*ma(cont))+res_mm1(k);
k2=y2(1)+(y2(2)*Tr_mm(i))+(y2(3)*ma(cont))+res_mm2(l);
%Parametri della B(pigreco)
par1=-(Tr_mm(i)-Tj_mm(j));
par2=Tr_mm(i)-Tr_mm(j);

%Cicli di controllo per evitare che si scelgano matrici che abbiano

%cinetiche che superano i valori consentiti
if (k1<k1_min)
k1= k1_min;
end
if (k1>k1_max)
k1=k1_max;
end
if (k2<k2_min)
k2=k2_min;
end
if (k2<k2_max)
k2=k2_max;
end
%Matrice dinamica del sistema A(Tr,Tj,res,delta)=A(pi)
A=[-k1,0,0,0;k1,-k2,0,0;alfa1*(k1),alfa2*(k2),-(US*alfar),US*alfar;0, 0,
US*alfaj,-((alfaj*US)+betaj)];
%Matrice B1(Tr,Tj)
B1=[0 0;0 0;par1 0;0 par2];
%Matrici valutate con eval
eval(['A1_',num2str(cont),'=A'])
B1cap=[B1 zeros(4,2)];
eval(['B1_',num2str(cont),'=B1cap'])
end %chiudo 1° for

end %chiudo 2° for

end %chiudo 3° for

end %chiudo 4° for

end %chiudo 5° for

Sintesi dell’osservatore e problema H∞ a 5 parametri.
La trasformazione multi affine del termine quadratico, parte degli sviluppi di Taylor
delle cinetiche di reazione, permette di formulare il problema di sintesi H∞ in maniera
molto agevole come segue. Qui di seguito le matrici del problema H∞ in funzione
dell’errore, grazie al teorema di dualità.

%Matrici dell'osservatore dopo l'approssimazione politopica, scritte in

%forma H_infinito.
B2=-eye(4);
C1=eye(4);
C2=[0 0 1 0;0 0 0 1];
D11_tilde=10^-1*C2';
D11=[zeros(4,2),D11_tilde];
D12=zeros(4);
D21_tilde=10^-1*eye(2);
D21=[zeros(2,2),D21_tilde];
D22=zeros(2);
%Costruisco una matrice allargata Astar costituita dalle matrice ottenute
%dalla sostituzione dei vertici dei politopi,in modo tale che scorrendola
%sia possibile estrapolare le matrici A1_i

Astar=[A1_1;A1_2;A1_3;A1_4;A1_5;A1_6;A1_7;A1_8;A1_9;A1_10;A1_11;A1_12;A1_13;A1_1
4;A1_15;A1_16;A1_17;A1_18;A1_19;

A1_20;A1_21;A1_22;A1_23;A1_24;A1_25;A1_26;A1_27;A1_28;A1_29;A1_30;A1_31;A1_32;];
%Allo stesso modo costruisco la matrice Bstar inerente a B(pigreco)

B1star=[B1_1;B1_2;B1_3;B1_4;B1_5;B1_6;B1_7;B1_8;B1_9;B1_10;B1_11;B1_12;B1_13;B1_
14;B1_15;B1_16;B1_17;B1_18;B1_19;B1_20;B1_21;B1_22;
B1_23;B1_24;B1_25;B1_26;B1_27;B1_28;B1_29;B1_30;B1_31;B1_32;];
B1_23;B1_24;B1_25;B1_26;B1_27;B1_28;B1_29;B1_30;B1_31;B1_32;];

E’ possibile scegliere la regione del piano complesso, in modo da fare evolvere le

dinamiche del sistema nella maniera desiderata, fissando lo smorzamento minimo
zita_min, la frequenza massima omegan_max, i poli a più bassa frequenza, l’angolo di
smorzamento dei poli e il guadagno |delta|<gamma come da teorema del piccolo
guadagno (|gamma|<1). Si imposta il problema di ottimizzazione con un set di 3 LMI
ottenendo 96 matrici (3x32).

%In base alle dinamiche del sistema fisso una specificata regione del piano
%complesso Reg(a_min, zita_min, omegan_max)
zita_min=0.701;
omegan_max=95;
%parte reale di a+jb e a-jb (polo a più bassa frequenza)
a_min=10^-5;
%Calcolo l'angolo di smorzamento dei poli
theta=acos(zita_min);
%Fisso il guadagno gamma dal teorema del piccolo guadagno |delta|<gamma
%dove |delta|=0.35
gamma=0.6;
%Imposto le LMI per la risoluzione del problema di
%ammissibilità(Feasibility Problem).
%Otterrò un sistema di lmi formato da 3 LMI.
setlmis([])
%P matrice simmetrica piena 4*4
P=lmivar(1,[4,1])
%W matrice rettangolare 4*2
W=lmivar(2,[4,2])
%Riazzero i contatori
cont1=1;
cont2=4;
for n=1:32
%1°Blocco_di_LMI
%____________________________________________________________
%[A'i*P+P*Ai+C2'*W'+W*C2+2*alfamin*P P*B1+W*D21 C1';
% (P*B1+W*D21)' -gamma*I D11';
% C1 D11 -gamma*I;]
%____________________________________________________________
% ----------------------------
% 1a LMI
% ----------------------------
% 1a riga
lmiterm([n,1,1,P],1,Astar(cont1:cont2,:),'s')
lmiterm([n,1,1,W],1,C2,'s')
lmiterm([n,1,1,P],2*a_min,1)
lmiterm([n,1,2,P],1,B1star(cont1:cont2,:))
lmiterm([n,1,2,W],1,D21)
lmiterm([n,1,3,0],C1')
%2a riga
lmiterm([n,2,2,0],-gamma)
lmiterm([n,2,3,0],D11')
%3a riga
lmiterm([n,3,3,0],-gamma)
cont1=cont2+1;
cont2=cont1+3;
end
%Riazzero i contatori
cont1=1;
cont2=4;
for n=33:64
%2°blocco di LMI
%___________________________________________________________
%[-omegan_max*P P*Ai+W*C2;
% (P*Ai+W*C2)' -omegan_max*P;]
%___________________________________________________________
%
%------------------------------
%2a LMI
%------------------------------
%1a riga
lmiterm([n,1,1,P],-omegan_max,1)
lmiterm([n,1,2,P],1,Astar(cont1:cont2,:))
lmiterm([n,1,2,W],1,C2)
%2a riga
lmiterm([n,2,2,P],-omegan_max,1)
cont1=cont2+1;
cont2=cont1+3;
end
%riazzero i contatori
cont1=1;
cont2=4
for n=65:96
%3°blocco di LMI
% _________________________________________________________________________
%
%[sin(theta)*(A'i*P+P*Ai+C2'*W'+W*C2) cos(theta)*(A'i*P-P*Ai+C2'*W'-W*C2);

% cos(theta)*(A'i*P-P*Ai+C2'*W'-W*C2)' sin(theta)*(A'i*P+P*Ai+C2'*W'+W*C2);]
%__________________________________________________________________________
%-------------------------------
%3a LMI
%-------------------------------
%1a riga
lmiterm([n,1,1,P],sin(theta),Astar(cont1:cont2,:),'s')
lmiterm([n,1,1,W],sin(theta),C2,'s')
lmiterm([n,1,2,-P],cos(theta)*Astar(cont1:cont2,:)',1)
lmiterm([n,1,2,P],-cos(theta),Astar(cont1:cont2,:))
lmiterm([n,1,2,-W],cos(theta)*C2',1)
lmiterm([n,1,2,W],-cos(theta),C2)
%2a riga
lmiterm([n,2,2,P],sin(theta),Astar(cont1:cont2,:),'s')
lmiterm([n,2,2,W],sin(theta),C2,'s')
cont1=cont2+1;
cont2=cont1+3;
end
%Ottengo il sistema LMI
lmisys=getlmis;
%Calcolo il problema di ammissibilità con feasp
[Tmin,Xfeas]=feasp(lmisys)
%Ricaviamo le soluzioni delle lmi
P=dec2mat(lmisys,Xfeas,P)
W=dec2mat(lmisys,Xfeas,W)
%Ricavo il guadagno di anello soluzione del problema Hinf
L=-inv(P)*W
%matrici per la simulazione
B=[0 0 0 betaj]';
C=[0 0 1 0;0 0 0 1];
D=[0 0]';
sim('schema_simulazione_hinf')
%Confronto fra i grafici relativi rispettivamente alle risposte del sistema al
segnale
%d'ingresso all'impianto e quelli dell'osservatore, inclusa la dinamica
dell'errore.
plot(t,Y1,'r')
grid on
hold on
plot(t,Ystimato,'--k')
legend('Risposta sistema non lineare y1=Tr','Risposta sistema non lineare
y2=Tj','risposta approssimata y1','risposta approssimata y2')
xlabel('Minuti [min]')
ylabel('Temperature [K]')
hold off
figure(2)
plot(t,e)
grid on
legend('Dinamica errore e1','Dinamica errore e2')
xlabel('Minuti [min]')
ylabel('Temperature [K]')
Qui di seguito viene mostrato il numero di iterazioni ed i passi di risoluzione del
problema LMI nel caso di funzione multiaffine a 5 parametri (32 matrici).
Il numero di iterazioni del problema è 18. Nel paragrafo successivo verrà mostrata una
soluzione algoritmicamente ottimizzata.

Figura 1-Passi di computazione problema LMI a 5 parametri

Soluzione del problema a 4 parametri e sintesi del problema H∞
In questo caso si utilizza una semplificazione algoritmica che diminuisce i cicli di
iterazione del problema e li riduce a 15, ma non è stato adottato come soluzione per la
tesi, è stata preferita la risoluzione a 5 parametri. La funzione di ricoprimento multi
affine può essere ridotta a 4 parametri e 2 indici (24=16 matrici o vertici del politopo)
con parametri Tr, Tj, con un solo residuo res_mm=[min(min(e1),min(e2)),
max(max(e1),max(e2))], δ(delta). Il numero di matrici del problema LMI passano da 96
(3x32) a 48 (3x16) come è possibile verificare dal ciclo for del problema LMI qui di
seguito implementato.
%Definisco i vettori degli estremi massimi e minimi per ogni parametro
Tr_mm=[min(Tr),max(Tr)];
Tj_mm=[min(Tj),max(Tj)];
res_mm=[min(min(e1),min(e2)) max(max(e1),max(e2))];
delta=[0 1];
%Costanti cinetiche massime e minime
k1_min=0.0018;
k1_max=1.4646;
k2_min=1.4999e-5;
k2_max=1.0917;

% Uso il ricoprimento politopico in modo tale da rendere il problema

% convesso.
%Inizializzo un contatore
cont=0;
%Costruisco i cicli for innestati
for i=1:2 %per Tr
for j=1:2 %per Tj
for k=1:2 %per res
for l=1:2 %per delta

cont=cont+1;
%Calcolo i vertici attraverso la funzione multi affine del file multiaffine.m
per la parabola Tr^2=F(Tr,Tj,res,delta). Dove ci sono 4 parametri.

%--------------------------------------------------------------------------
%Funzione per il calcolo della funzione multiaffine di
%ricoprimento politopico per il termine parabola f(p)=p^2
%--------------------------------------------------------------------------
function f=multiaffine(xr,xj,res,delta)
%p è il parametro incerto, delta è un parametro compreso tra [0,1]
Tr=[ 293.15,300,310,315,320,329.02,325,320,315,308.15];
Tj=[310,326.7158826,335.8491054,338.4149386,337.0468731,325.2849698,313.4909946,
...
306.4442608, 303.835378, 307.1230027];
res=[-0.00183924238486 0.00219829578479];
xrmax= max(Tr);
xrmin=min(Tr);
xjmax=max(Tj);
xjmin=min(Tj);
resmax=max(res);
resmin=min(res);

%Vettori di componenti massime e minime.

pmax=[xrmax xjmax resmax ];
pmin=[xrmin xjmin resmin ];
p=[xr xj res ];
for i=1:3
if p(i)>pmax(i)|p(i)<pmin(i)
error('sei fuori dagli intervalli dei valori ammissibili')
end
end
if delta<0|delta>1
error('sei fuori dagli intervalli ammissibili')
end

for i=1:3
f1(i)=(pmin(i))^2+(2*pmin(i)*(p(i)-pmin(i)));
f2(i)=(((pmax(i)+pmin(i))*p(i))-(pmin(i)*pmax(i)));
end
f_low=sum(f1);
f_up=sum(f2);
f=(delta*f_low)+((1-delta)*f_up);

Viene richiamata la funzione multi affine a 4 parametri:

ma(cont)=multiaffine(Tr_mm(i),Tj_mm(j),res_mm(k),delta(l));
%--------------------------------------------------------------------------
%-------------------Scrivo il sistema in forma Hinf------------------------
%-----------epunto=A1,i(pi)*e+B1(pi)*ew+B2(pi)*eu--------------------------
%-----------ez=C1(pi)*e+D11(pi)*ew+D12(pi)*eu------------------------------
%-----------ey=C2(pi)*e+D21(pi)*ew+D22(pi)*eu------------------------------
%--------------------------------------------------------------------------
%Parabola a cui è stato sostituito il suo sviluppo politopico
k1=y1(1)+(y1(2)*Tr_mm(i))+(y1(3)*ma(cont))+res_mm(k);
k2=y2(1)+(y2(2)*Tr_mm(i))+(y2(3)*ma(cont))+res_mm(k);
%Parametri della B1(pigreco)
par1=-(Tr_mm(i)-Tj_mm(j));
par2=Tr_mm(i)-Tr_mm(j);
%Cicli di controllo per evitare che si scelgano matrici che abbiano
%cinetiche che superano i valori consentiti
if (k1<k1_min)
k1= k1_min;
end
if (k1>k1_max)
k1=k1_max;
end
if (k2<k2_min)
k2=k2_min;
end
if (k2<k2_max)
k2=k2_max;
end
%Matrice dinamica del sistema A(Tr,Tj,res,delta)=A(pi)
A=[-k1,0,0,0;k1,-k2,0,0;alfa1*(k1),alfa2*(k2),-(US*alfar),US*alfar;0, 0,
US*alfaj,-((alfaj*US)+betaj)];
%Matrice B1(Tr,Tj)
B1=[0 0;0 0;par1 0;0 par2];
B1cap=[B1,zeros(4,2)]
%Matrici valutate con eval
eval(['A1_',num2str(cont),'=A'])
eval(['B1_',num2str(cont),'=B1cap'])
end
end
end
end
%Matrici dell'osservatore dopo l'approssimazione politopica, scritte in
%forma H_infinito.

B2=-eye(4);

C1=eye(4);

C2=[0 0 1 0;0 0 0 1];

D11_tilde=10^-1*C2';

D11=[zeros(4,2),D11_tilde];

D12=zeros(4);

D21_tilde=10^-1*eye(2);

D21=[zeros(2),D21_tilde];

D22=zeros(2);
%Costruisco una matrice allargata Astar costituita dalle matrice ottenute
%dalla sostituzione dei vertici dei politopi,in modo tale che scorrendola
%sia possibile estrapolare le matrici A1_i
Astar=[A1_1;A1_2;A1_3;A1_4;A1_5;A1_6;A1_7;A1_8;A1_9;A1_10;A1_11;A1_12;A1_13;A1_1
4;A1_15;A1_16];
%Costruisco la B1star
B1star=[B1_1;B1_2;B1_3;B1_4;B1_5;B1_6;B1_7;B1_8;B1_9;B1_10;B1_11;B1_12;B1_13;B1_
14;B1_15;B1_16];
%In base alle dinamiche del sistema fisso una specificata regione del piano
%complesso Reg(a_min, zita_min, omegan_max)
zita_min=0.7;
omegan_max=90;
%parte reale di a+jb e a-jb (polo a più bassa frequenza)
a_min=-10^-5;
%Calcolo l'angolo di smorzamento dei poli
theta=acos(zita_min);
%Fisso il guadagno gamma dal teorema del piccolo guadagno |delta|<gamma
%dove |delta|=0.35
gamma=0.6;
%Imposto le LMI per la risoluzione del problema di
%ammissibilità(Feasibility Problem).
%Otterrò un sistema di lmi formato da 3 LMI.
setlmis([])
%P matrice simmetrica piena 4*4
P=lmivar(1,[4 1])
%W matrice rettangolare 4*2
W=lmivar(2,[4,2])
%Riazzero i contatori
cont1=1;
cont2=4;
for n=1:16
%1°Blocco_di_LMI
%____________________________________________________________
%[A'i*P+P*Ai+C2'*W'+W*C2+2*alfamin*P P*B1+W*D21 C1';
% (P*B1+W*D21)' -gamma*I D11';
% C1 D11 -gamma*I;]
%____________________________________________________________
% ----------------------------
% 1a LMI
% ----------------------------
% 1a riga
lmiterm([n,1,1,P],1,Astar(cont1:cont2,:),'s')
lmiterm([n,1,1,W],1,C2,'s')
lmiterm([n,1,1,P],2*a_min,1)
lmiterm([n,1,2,P],1,B1star(cont1:cont2,:))
lmiterm([n,1,2,W],1,D21)
lmiterm([n,1,3,0],C1')
%2a riga
lmiterm([n,2,2,0],-gamma)
lmiterm([n,2,3,0],D11')
%3a riga
lmiterm([n,3,3,0],-gamma)
cont1=cont2+1;
cont2=cont1+3;
end
%Riazzero i contatori
cont1=1;
cont2=4;
for n=17:32
%2°blocco di LMI
%___________________________________________________________
%[-omegan_max*P P*Ai+W*C2;
% (P*Ai+W*C2)' -omegan_max*P;]
%___________________________________________________________
%
%------------------------------
%2a LMI
%------------------------------
%1a riga
lmiterm([n,1,1,P],-omegan_max,1)
lmiterm([n,1,2,P],1,Astar(cont1:cont2,:))
lmiterm([n,1,2,W],1,C2)
%2a riga
lmiterm([n,2,2,P],-omegan_max,1)
cont1=cont2+1;
cont2=cont1+3;
end
%riazzero i contatori
cont1=1;
cont2=4
for n=33:48
%3°blocco di LMI
% _________________________________________________________________________
%
%[sin(theta)*(A'i*P+P*Ai+C2'*W'+W*C2) cos(theta)*(A'i*P-P*Ai+C2'*W'-W*C2);

% cos(theta)*(A'i*P-P*Ai+C2'*W'-W*C2)' sin(theta)*(A'i*P+P*Ai+C2'*W'+W*C2);]
%__________________________________________________________________________

%-------------------------------
%3a LMI
%-------------------------------

%1a riga
lmiterm([n,1,1,P],sin(theta),Astar(cont1:cont2,:),'s')
lmiterm([n,1,1,W],sin(theta),C2,'s')
lmiterm([n,1,2,-P],cos(theta)*Astar(cont1:cont2,:)',1)
lmiterm([n,1,2,P],-cos(theta),Astar(cont1:cont2,:))
lmiterm([n,1,2,-W],cos(theta)*C2',1)
lmiterm([n,1,2,W],-cos(theta),C2)
%2a riga
lmiterm([n,2,2,P],sin(theta),Astar(cont1:cont2,:),'s')
lmiterm([n,2,2,W],sin(theta),C2,'s')
cont1=cont2+1;
cont2=cont1+3;
end
%Ottengo il sistema LMI
lmisys=getlmis;
%Calcolo il problema di ammissibilità con feasp
[Tmin,Xfeas]=feasp(lmisys)
%Ricaviamo le soluzioni delle lmi
P=dec2mat(lmisys,Xfeas,P)
W=dec2mat(lmisys,Xfeas,W)
%Ricavo il guadagno di anello soluzione del problema Hinf
L=-inv(P)*W
%matrici per la simulazione
B=[0 0 0 betaj]'
C=[0 0 1 0;0 0 0 1]
D=[0 0]'
sim('schema_simulazione_hinf')
%Confronto fra i grafici relativi rispettivamente alle risposte del sistema al
segnale
%d'ingresso all'impianto e quelli dell'osservatore, inclusa la dinamica
dell'errore.
plot(t,Y1,'r')
grid on
hold on
plot(t,Ystimato,'--k')
legend('Risposta sistema non lineare y1=Tr','Risposta sistema non lineare
y2=Tj','risposta approssimata y1','risposta approssimata y2')
xlabel('Minuti [min]')
ylabel('Temperature [K]')
hold off
figure(2)
plot(t,e)
grid on
legend('Dinamica errore e1','Dinamica errore e2')
xlabel('Minuti [min]')
ylabel('Temperature [K]')
Come detto all’inizio del paragrafo il numero di passi di iterazione risulta ridotto a 15
e le simulazioni sono analoghe a quello a 5 parametri. Il numero di passi ridotto è
quello rappresentato in figura. Le simulazioni sono analoghe a quelle a 5 parametri
ma con una velocità di computazione più alta.

Figura 2-Passi di computazione problema LMI a a parametri.