Sei sulla pagina 1di 19

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 lUniversit Mediterranea degli Studi di
Reggio Calabria-anno 2005

16/9/2017
Sommario

Introduzione .................................................................................................................................. 2
Sistemi con non linearit esponenziali e algoritmo numerico di linearizzazione di un reattore
batch. ............................................................................................................................................. 3
Sintesi dellosservatore 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 lutilizzo 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, quindi possibile rendere noto lapproccio algoritmico usato
per la risoluzione del problema di sintesi dellosservatore H , che permette di
migliorare sensibilmente la stima delle concentrazione e delle temperature di un
reattore esotermo attraverso losservazione degli stati interni a partire dalle uscite del
sistema, senza operare trasformazioni fisiche sulla struttura interna del reattore,
aggiungendo dei sensori. Il tutorial parte dal codice Matlab e viene spiegato passo per
passo: si parte dalla rappresentazione numerica ISU del reattore con i dati forniti
dallUniversit della Basilicata per poi descrivere lalgoritmo di linearizzazione e il
problema di ottimizzazione con luso di LMI (Linear Matrix Inequality). Per gli
argomenti trattati si richiede almeno la conoscenza dellalgebra lineare, della
programmazione matematica e ricerca operative, 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. Lalgoritmo consiste nei seguenti passi:

Definizione di uno sviluppo parabolico per le due cinetiche di reazione


dipendenti dalluscita 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 dellimpianto batch in formato numerico:
%Dati sperimentali forniti dall'Universit della Basilicata e rappresentazione
ISU del modello del reattore e matrice dellosservatore 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 dallarticolo scientifico fornito
alluniversit
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 sullimpianto.

%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 dellesponenziale 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 sullintervallo 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) sullintervallo 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 dallinterpolazione 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 multiaffine del


termine quadratico dello sviluppo delle cinetiche di reazione, che nellalgoritmo
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 dellerrore.

% 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 dellosservatore 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
dellerrore, 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, langolo 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
%1Blocco_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
%2blocco 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
%3blocco 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
%1Blocco_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
%2blocco 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
%3blocco 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 allinizio 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.