ESERCITAZIONE 1 - SOLUZIONE DI SISTEMI LINEARI

Si vuole risolvere il generico sistema lineare in n equazioni

a
11
x
1
+a
12
x
2
+.+a
1n
x
n
= b
1
a
21
x
1
+a
22
x
2
+.+a
2n
x
n
= b
2
.
.
a
n1
x
1
+a
n2
x
2
+.+a
nn
x
n
= b
n
che viene generalmente indicato nella forma compatta A x = b con A
nn
matrice dei
coefficienti, b
n
termine noto e x
n
vettore delle incognite.
La soluzione immediata rappresentata da x = A
1
b , ma che presenta uno sforzo
computazionale elevato per invertire la matrice dei coefficienti.
Esistono delle tecniche alternative per la soluzione dei sistemi lineari rappresentate da:
- metodi diretti: forniscono una soluzione in un numero finito di operazioni
1
trasformando
un generico sistema lineare in un sistema equivalente, dotato di un
struttura che ne rende pi semplice la risoluzione; il processo
indipendente dall'accuratezza desiderata:
- eliminazione di Gauss con pivoting;
- fattorizzazione di Cholesky-Taylor;
- metodi iterativi: forniscono una soluzione in un numero indefinito di passi in funzione di
una tolleranza assegnata; l'accuratezza dipende del numero di passi
effettuati:
- Jacobi;
- Gauss-Seidel.
In questa esercitazione si sviluppa un programma Matlab per il metodo della fattorizzazione
di Cholesky-Taylor e un altro per il metodo iterativo di Jacobi.
1.1 Fattorizzazione di Cholesky-Taylor
La matrice A dei coefficienti viene scomposta in due matrici
2
triangolari:
L U =
|
l
11
0 0 0 0
l
21
l
22
0 0 0
l
31
l
32
l
33
0 0
0
l
11
. . . l
nn

|
1 u
12
u
13
. u
1n
0 1 u
23
. u
2n
0 0 1
0 0 0 1 u
qn
0 0 0 0 1

= A
tali che il sistema possa essere riscritto nella forma L U x = b ; a questo punto si opera la
sostituzione y = Ux e si ottiene il sottosistema L y = b , che non necessita dell'inversione
della matrice L per essere risolto dal momento che si procede con i seguenti passi:
- risoluzione della prima equazione, che risulta in una sola variabile;
- sostituzione del valore trovato nell'equazione seguente;
- prosecuzione fino all'ultima equazione.
Tale procedura definita di forward substitution (sostituzione in avanti).
1 La soluzione risulta esatta in assenza di errori di arrotondamento.
2 L'indice q nella matrice U pari a (n-1).
1
Il vettore soluzione y cos ottenuto rappresenta il termine noto per il sottosistema U x = y ,
che come prima non necessita dell'inversione della matrice dei coefficienti, ma a differenza
della procedura precedente avviene secondo i seguenti passi:
- risoluzione dell'ultima equazione, che risulta in una sola variabile;
- sostituzione del valore trovato nell'equazione precedente;
- prosecuzione a ritroso fino alla prima equazione.
Tale procedura definita di backward substitution (sostituzione all'indietro).
Di seguito si riporta l'implementazione del metodo in linguaggio Matlab.
% Risoluzione sistemi lineari
% Metodo diretto
% Fattorizzazione di Cholesky-Taylor

clear all;

load 'matrice.txt'; % Lettura elementi da file matrice.txt
A = matrice; % Assegnazione a matrice A
load 'termini_noti.txt'; % Lettura elementi da file termini_noti.txt
b = termini_noti; % Assegnazione a vettore b

n = size (A,1); % Dimensione righe matrice
m = size (A,2); % Dimensione colonne matrice
r = size (b,1); % Dimensione vettore termini_noti
clear matrice termini_noti;
Dopo aver caricato i file contenenti gli elementi della matrice dei coefficienti e dei termini
noti si effettuano dei controlli riguardo le dimensioni degli stessi e la non singolarit della
matrice.
%--------------Controlli iniziali sulle dimensioni-------------------------
if n ~= m
disp ('Errore: Matrice non quadrata');
elseif det(A)==0
disp ('Errore: Dimensione vettore dei termini noti diversa dalla');
disp (' dimensione della matrice dei coefficienti');
%--------------Controllo iniziale se matrice singolare---------------------
elseif n ~= r
disp ('Errore: Determinante matrice uguale a zero');
else
clear m r;
Le assegnazioni iniziali
3
delle matrici L ed U servono per effettuare le operazioni nei cicli
successivi ed ottimizzare l'esecuzione del programma.
L'inizializzazione dei contatori ha la funzione di tenere sotto controllo i cicli.
%--------------Assegnazioni iniziali della fattorizzazione-----------------
L = zeros (n,n); % Assegnazione zeri a L
U = eye (n); % Assegnazione zeri e uno a U
L(:,1) = A(:,1); % Assegnazione prima colonna a L

k = 2; % Contatore dei cicli
p = 2; % Contatore della riga mobile nello scambio
s = 1; % Contatore della riga fissa nello scambio
3 Preallocation.
2
Appena inizia il ciclo risulta necessario inserire un controllo sull'elemento
L
i , i
; nel caso sia
uguale a zero si effettua lo scambio tra righe
4
, e di conseguenza si devono reinizializzare le
assegnazioni delle matrici ed anche il contatore k.
while k <= n %---------INIZIO CICLO-------------------------------
%---------Controllo che per ogni ciclo l'elemento sulla diagonale di L sia-
%---------diverso da zero--------------------------------------------------
if L(k-1,k-1) == 0
L = zeros (n,n);% Nel caso si riassegnano gli elementi iniziali
U = eye (n); % e il contatore k
k = 2;
scambioA = A(s,:); scambiob = b(s); % Scambio delle righe
A(s,:) = A(p,:); b(s) = b(p); % di A e dei conseguenti
A(p,:) = scambioA; b(p)= scambiob; % elementi di b
L(:,1) = A(:,1); % Riassegnazione prima colonna a L
Per i contatori p ed s si aggiunge l'ulteriore controllo affinch non superino la dimensione n
della matrice, dal momento che essi influiscono sugli indici della stessa.
if s == n % Controllo sui contatori s e p
s = 1; p = 2; % che non superino la dimensione
else % della matrice
if p == n % Essendo la matrice che passa i
s = s+1; p = s+1; % controlli iniziali non singolare
else % non presente il rischio di
p = p+1; % riassegnazione infinita
end
end
%----------(Fine controllo)------------------------------------------------
Una volta effettuati tutti i necessari controlli si passa alla fattorizzazione.
else
%----------Fattorizzazione di Cholesky-Taylor------------------------------
for i = k:n
% assegnazione di U per righe
U(k-1,i) = (A(k-1,i) - L(k-1,:)*U(:,i)) / L(k-1,k-1);
% assegnazione di L per colonne
L(i,k) = A(i,k) - L(i,:)*U(:,k);
end
k = k+1;
end
end %-----------FINE CICLO--------------------------------
Infine si sono implementati i due metodi risolutivi e la stampa dei risultati a video.
%-----------------------Sostituzione in avanti-----------------------------
y = zeros (n,1);
for i = 1:n
y(i)=(b(i)-L(i,:)*y)/L(i,i);
end
%-----------------------Sostituzione all'indietro--------------------------
x = zeros (n,1);
for i = n:-1:1
x(i)=(y(i)-U(i,:)*x)/U(i,i);
end
%--------------------------------------------------------------------------
clear y i k n p s;
disp ('vettore soluzione =');
disp (x);
end
4 Lo scambio tra righe si effettua per non alterare la soluzione.
3
1.2 Metodo iterativo di Jacobi
Un metodo iterativo lineare
5
, stazionario
6
e di primo grado
7
assume la forma:
x
(k+1)
= B x
( k)
+c
in cui k rappresenta il passo d'iterazione. La convergenza del metodo dipende dalla matrice
d'iterazione B ; infatti un metodo lineare convergente se e solo se l'autovalore di modulo
massimo risulta minore di 1.
Per la costruzione di un metodo iterativo generico si procede tramite la tecnica dello splitting:
- decomposizione della matrice A = MN con det (M) 0 ;
-
il sistema di origine diventa Mx=Nxb x=M
1
NxM
1
b ;
-
definizione del metodo iterativo x
(k+1)
= B x
(k)
M
1
b con B = M
1
N .
Per rendere il metodo computazionalmente efficace si deve rendere la matrice M pi
semplice da invertire della matrice A; la tecnica di Jacobi consiste nel porre M = D dove
D =
|
a
11
0 0 0
0 a
22
0 0
0 0 0
0 0 0 a
nn

da cui
B = M
1
N = IM
1
A = ID
1
A
e quindi
x
(k+1)
= (ID
1
A) x
( k)
D
1
b
dove
D
1
=
|
1/ a
11
0 0 0
0 1/ a
22
0 0
0 0 0
0 0 0 1/ a
nn

Per terminare l'iterazione si rende necessario utilizzare dei criteri di arresto:

1) si controlla la differenza tra due iterazioni successive, fissata una tolleranza e scelta una
norma vettoriale
x
(k+1)
x
( k)

oppure con il controllo dello scarto relativo
x
( k+1)
x
( k)

x
( k)

rel
;
2) per evitare un loop infinito
8
opportuno fissare un numero massimo di iterazioni.
5 La funzione che esprime x lineare.
6 La matrice B non varia al variare del passo d'iterazione.
7 L'iterazione k+1 coinvolge solo l'iterazione k.
8 Eventualit nel caso di non convergenza o errore di implementazione.
4
Di seguito si riporta l'implementazione del metodo in linguaggio Matlab.
La prima parte del programma del tutto analoga a quella del metodo diretto.
% Risoluzione sistemi lineari
% Metodo iterativo
% Jacobi
clear all;
load 'matrice.txt'; % Lettura elementi da file matrice.txt
A = matrice; % Assegnazione a matrice A
load 'termini_noti.txt'; % Lettura elementi da file termini_noti.txt
b = termini_noti; % Assegnazione a vettore b

n = size (A,1); % Dimensione righe matrice
m = size (A,2); % Dimensione colonne matrice
r = size (b,1); % Dimensione vettore termini_noti
clear matrice termini_noti;
Si aggiunge un input che riguardano le condizioni di arresto delle iterazioni, mentre i controlli
iniziali rimangono inalterati.
e = input('Tolleranza relativa (in %): ');
iter = input('Numero massimo di iterazioni: ');
if n ~= m
disp ('Errore: Matrice non quadrata');
elseif det(A)==0
disp ('Errore: Determinante matrice uguale a zero');
elseif n ~= r
disp ('Errore: Dimensione vettore dei termini noti diversa dalla');
disp (' dimensione della matrice dei coefficienti');
else
Il programma si differenzia dal precedente da questo punto. Sulla matrice dei coefficienti si
effettua solo un controllo sugli elementi della diagonale principale che devono risultare
diversi da zero; in caso contrario si effettuano degli scambi tra righe. Il ciclo di scambio non
ha possibilit di entrare in un ciclo infinito visto che la matrice che ha passato i controlli
iniziali risulta non singolare.
%-----------Controllo sugli elementi della diagonale principale di A-------
for j = 1:n
k = j+1;
while A(j,j) == 0
if k <= n
scambioA = A(j,:); scambiob = b(j);
A(j,:) = A(k,:); b(j) = b(k);
A(k,:) = scambioA; b(k)= scambiob;
k = k+1;
else
k = 1;
end
end
end
Si prosegue costruendo la matrice D
1
che non necessita del comando inv(D).
%-----------Costruzione matrici D e inversa di D---------------------------
D = zeros (n); invD = zeros (n);
for i=1:n
D(i,i) = A(i,i); % D solo con elementi della diagonale di A
invD(i,i) = 1/A(i,i); % => inversa di D = 1/A(i,i)
end
5
Il controllo sulla convergenza viene effettuato tramite il comando eig(B) che calcola gli
autovalori della matrice.
%-----------Controllo sulla convergenza------------------------------------
B = eye(n)-invD*A;
AutMax = max(abs(eig(B)));
if AutMax >= 1
disp('Soluzione non convergente');
fprintf ('Autovalore di modulo massimo di B = %3.1f \n', AutMax);
else
A questo punto il controllo sul numero massimo di iterazioni sarebbe superfluo visto il
controllo precedente sulla convergenza; il metodo viene implementato senza ulteriori
elaborazioni nella forma xi = (eye(n) - invD*A)*x + invD*b in cui xi, che rappresenta
il vettore soluzione al passo k+1, viene sostituito di volta in volta nella ripetizione del ciclo.
%-----------Algoritmo di Jacobi--------------------------------------------
x = zeros (n,1); xi = zeros (n,1);
norma1 = 1; i = 0;
while norma1*100 > e*sum(abs(x)) && i < iter
xi = (eye(n) - invD*A)*x + invD*b;
norma1 = sum (abs (xi-x));
x = xi;
i = i+1;
end
disp(x);
fprintf ('Numero di iterazioni = %4i \n', i);
end
clear e iter j k m n r xi;
end
1.3 Esempi applicativi
Per il metodo diretto stato creato un programma che costruisce una matrice di coefficienti e
un vettore di elementi noti casuali:
1) Matrice coefficienti Vettore termini noti Soluzione a video
|
81 10 16 14 66
91 28 97 42 4
13 55 96 92 85
91 96 49 79 93
63 96 80 96 68
|
76
74
39
66
17

vettore soluzione =
-0.7588
3.4242
3.5584
-7.3094
2.2518
La stessa matrice stata rielaborata per inserire degli zeri in maniera casuale e rendere la
diagonale principale predominante:
2) Matrice coefficienti Vettore termini noti Soluzione a video
|
81 10 0 4 0
0 28 7 0 4
13 15 96 2 0
1 0 49 79 3
0 6 0 0 68
|
76
74
39
0
17

vettore soluzione =
-1.2562
2.6166
0.1697
-0.1029
0.4809
6
Un ultimo caso si inserito un esempio trovato in letteratura:
3) Matrice coefficienti Vettore termini noti Soluzione a video
|
1 2 3 1 0
0 1 1 2 3
1 1 1 0 2
0 2 0 1 3
1 1 2 0 1
|
1
1
2
4
5

vettore soluzione =
-4.0000
13.2000
8.4000
-6.2000
5.4000
Gli stessi esempi applicati al metodo iterativo forniscono i seguenti risultati:
1) Tolleranza
relativa
Numero massimo
iterazioni
Soluzione a video
0.0001 100
Soluzione non convergente
Autovalore di modulo massimo di B = 3.9
2) Tolleranza
relativa
Numero massimo
iterazioni
Soluzione a video
0.0001 100
-1.2562
2.6166
0.1697
-0.1029
0.4809
Numero di iterazioni = 11
3) Tolleranza
relativa
Numero massimo
iterazioni
Soluzione a video
0.0001 100
Soluzione non convergente
Autovalore di modulo massimo di B = 3.8
1.4 Problemi riscontrati
I maggiori problemi si sono incontrati, per entrambi i metodi, nell'implementazione dei
controlli sugli elementi della matrice dei coefficienti A , mentre per il metodo diretto sul
controllo degli elementi della matrice L , soprattutto per quanto riguarda la variazione degli
indici per lo scambio tra righe.
7
8
ESERCITAZIONE 2 - RICERCA DEGLI ZERI PER EQUAZIONI NON
LINEARI
La generica equazione o funzione non lineare f (x) viene posta nella forma f (x) = 0 e si
definisce radice di f (x) se risulta f ( ) = 0 ; in termini numerici tale risultato si
raggiunge se f ( ) oppure x con = tolleranza .
Un'equazione di tale tipo non genericamente risolvibile analiticamente, tuttavia esistono
degli algoritmi che consentono di valutare tutte le radici che l'equazione presenta, od una
singola radice partendo da una soluzione approssimata. In questo secondo caso, che
rappresenta i metodi iterativi, le tecniche si dividono in:
- metodi chiusi: cercano la radice in un fissato intervallo:
- metodo di bisezione o dicotomico;
- metodi aperti: cercano la radice partendo da un valore fissato:
- metodo di Newton-Raphson;
- metodi quasi-Newton (delle secanti, regula falsi);
- iterazioni di punto fisso.
In questa esercitazione si sviluppa un function Matlab che considera insieme il metodo di
bisezione, di Newton-Raphson e l'iterazione di punto fisso. Tale function, applicabile ad un
generica equazione, viene verificata su uno specifico problema idraulico, implementato con
un programma e con function dedicate.
2.1 Cenni sui metodi
Per il metodo di bisezione, se si considerano gli estremi di un intervallo
x
a
e
x
b
, e risulta
f (x
a
) f ( x
b
) 0
allora esiste almeno una radice nell'intervallo considerato. Poi si definisce
x * =
x
a
x
b
2
e si valuta di volta in volta il valore di f (x *) riassegnandolo a
x
a
o
x
b
.
Il metodo di Newton-Raphson, partendo da un valore iniziale
x
0
, valuta al generico passo k
l'equazione della retta tangente a f (x) in
x = x
k
y f (x
k
)= f ' ( x
k
) (x
k+1
x
k
)
ottenendo, all'intersezione con l'asse x
x
k+1
=x
k

f (x
k
)
f ' (x
k
)
Entrambi i metodi arrestano la ricerca della soluzione quando si verifica
f (x
k+1
)
.
L'iterazione di punto fisso riscrive l'equazione come x = g (x) e la valuta ad ogni step come
x
k+1
=g ( x
k
)
arrestano la ricerca della soluzione quando si verifica
x
k+1
x
k

.
9
Di seguito si riporta l'implementazione del metodi nella function Matlab f_NonLineari.
function [xB,iB,xNR,iNR,f1,xPF,iPF,iter] = f_NonLineari ()

% Risoluzione equazioni non lineari
% Metodi di bisezione, Newton-Raphson, Punto fisso

clear all;

load 'metodi.txt'; % Lettura elementi da file metodi.txt

e = metodi(1);
xa = metodi(2); xb = metodi(3);
xi = metodi(4); iter = metodi(5);

%--------------------------------------------------------------------------
% Metodo della Bisezione
%--------------------------------------------------------------------------
fa = f_trap (xa); % VALORE FUNZIONE f INIZIALE
fb = f_trap (xb); % VALORE FUNZIONE f INIZIALE
iB = 0;
%------Controllo dell'esistenza di zeri nell'intervallo iniziale-----------
while (fa*fb) >= 0
disp('Non esistono zeri tra i valori iniziali');
xa = input('Valore estremo a: ');
xb = input('Valore estremo b: ');
fa = f_trap (xa); % VALORE FUNZIONE f INIZIALE
fb = f_trap (xb); % VALORE FUNZIONE f INIZIALE
end

%--------------Attivazione finestra grafica h1-----------------------------
close all; h1 = figure; whitebg(h1, 'white');
x = (xa:0.1:xb)'; assex = zeros(length(x),1);
f = f_trap (x); % VALORE FUNZIONE f IN GRAFICA
hold on;
xlabel('Valore di y','fontsize',10);
ylabel('Valore di f (y)','fontsize',10);
plot (x,f); plot (x,assex,'k:'); % stampa funzione e asse x
plot (xa,0,'k*'); plot (xb,0,'k*'); % stampa valori iniziali
title ('Bisezione','fontsize',10);

%--------------Inizio ciclo------------------------------------------------
% ciclo while funzione della sola tolleranza
fx = fa;
while abs(fx) > e % ciclo while in funzione della sola tolleranza
xB = (xa+xb)/2; % valore che divide a met l'intervallo
fx = f_trap (xB); % VALORE FUNZIONE f ALLO STEP
% Valutazione su quale valore mi avvicina alla soluzione
if (fa*fx) < 0
xb=xB;
else
xa=xB;
end
iB = iB+1; % incremento contatore
end
plot (xB,0,'ro'); % stampa valore finale

%--------------------------------------------------------------------------
% Newton Raphson (senza fattore di rilassamento)
%--------------------------------------------------------------------------
xa = metodi(2); xb = metodi(3); % Valori riassegnati solo per la grafica
10
xNR = xi;
fNR = f_trap (xi); % VALORE FUNZIONE f INIZIALE
f1 = f_trap (xi,1); % VALORE DERIVATA DI f INIZIALE
iNR = 0;
%--------------Attivazione finestra grafica h2-----------------------------
h2 = figure; whitebg(h2, 'white');
x = (xa:0.1:xb)'; assex = zeros(length(x),1);
f = f_trap (x); % VALORE FUNZIONE f IN GRAFICA
% comandi di grafica sulla finestra sinistra
subplot (1,2,1)
hold on;
xlabel('Valore di y','fontsize',10);
ylabel('Valore di f (y)','fontsize',10);
% stampa della funzione, dell'asse x e del valore iniziale
plot (x,f); plot (x,assex,'k:'); plot (xNR,0,'k*');
title ('Newton Raphson','fontsize',10)

%--------------Inizio ciclo------------------------------------------------
% ciclo while funzione della tolleranza, del numero di iterazioni e della
% derivata che sia non nulla

while abs(fNR) > e && iNR < iter && f1 ~= 0
fNR = f_trap (xNR); % VALORE FUNZIONE f ALLO STEP
f1 = f_trap (xNR, 1); % VALORE DERIVATA DI f ALLO STEP
% comandi di grafica sulla finestra sinistra
subplot (1,2,1)
plot ([xNR,xNR],[0,fNR],'r-');
xii = xNR - (fNR /f1 ); % y step successivo
% comandi di grafica sulla finestra sinistra
subplot (1,2,1)
plot ([xNR,xii],[fNR,0],'r-');
% comandi di grafica sulla finestra destra (tipo di convergenza)
subplot (1,2,2)
hold on; grid on;
xlabel('Numero iterazioni','fontsize',10);
ylabel('Valore di y','fontsize',10);
plot ([iNR,iNR+1],[xNR,xii],'r-');
title ('Convergenza','fontsize',10)
xNR = xii; % riassegnazione valore y
iNR = iNR+1; % incremento contatore
end

%--------------------------------------------------------------------------
% Punto Fisso
%--------------------------------------------------------------------------
xPF = xi;
iPF = 0;
diff = 10; % valore generico per fare iniziare il ciclo while

%--------------Attivazione finestra grafica h3-----------------------------
h3 = figure; whitebg(h3, 'white');
x = (xa:0.1:xb)';
f = g_trap (x); % VALORE FUNZIONE g IN GRAFICA
% comandi di grafica sulla finestra sinistra
subplot (1,2,1)
hold on;
xlabel('Valore di y','fontsize',10);
ylabel('Valore di g (y)','fontsize',10);
% stampa della funzione, dell'asse x e del valore iniziale
plot (x,f); plot (x,x,'k:'); plot (xPF,xPF,'k*');
title ('Punto Fisso','fontsize',10)

11
%--------------Inizio ciclo------------------------------------------------
% ciclo while funzione della tolleranza e del numero di iterazioni

while diff > e && iPF < iter
xii = g_trap (xPF); % VALORE FUNZIONE g ALLO STEP
% comandi di grafica sulla finestra sinistra
subplot (1,2,1)
plot ([xPF,xPF],[xPF,xii],'r-'); plot ([xPF,xii],[xii,xii],'r-');
% comandi di grafica sulla finestra destra (tipo di convergenza)
subplot (1,2,2)
hold on; grid on;
xlabel('Numero iterazioni','fontsize',10);
ylabel('Valore di y','fontsize',10);
plot ([iPF,iPF+1],[xPF,xii],'r-');
title ('Convergenza','fontsize',10)
diff = abs (xii-xPF); % differenza tra i valori
xPF = xii; % riassegnazione valore y
iPF = iPF+1; % incremento contatore
end
Per tutti i tre metodi si predisposta una finestra grafica con l'andamento dell'equazione e
della ricerca della soluzione; per i due metodi aperti si inoltre aggiunto l'andamento della
convergenza della soluzione al procedere dei passi di iterazione. Ogni eventuale commento
riportato nei paragrafi 1.3 e 1.4.
Il file metodi.txt contiene i valori iniziali e la tolleranza riferiti al problema analizzato, ed il
numero massimo di iterazioni eseguibili per i metodi aperti.
% Tolleranza:
0.0001
% Valore estremo a per metodo Bisezione:
1
% Valore estremo b per metodo Bisezione:
2
% Valore iniziale per metodi iterativi:
1
% Numero massimo di iterazioni:
100
Le function f_trap e g_trap fanno riferimento allo specifico problema idraulico riportato nel
paragrafo successivo.
1.2 Problema idraulico
Si vuole valutare la profondit a moto uniforme e la profondit critica in un canale prismatico
a sezione trapezia, assegnate una portata Q , una pendenza del fondo
i
f
e una scabrezza
k
s
.
T
B
y
A
m
1
dove
A = sezione liquida = y (B+my)
P = perimetro bagnato = B+2y (1+m
2
)
1/ 2
T = larghezza pelo libero = B+2my
12
L'equazione del moto uniforme nella forma di Gauckler-Strickler in funzione della portata
Q = k
s
R
2/ 3
i
f
1/2
A = k
s
A
5/3
P
2/ 3

y=y
u
i
f
1/ 2
mentre per la profondit critica risulta
A
3
T

y =y
c
=
Q
2
g
Per il metodo della bisezione sufficiente mettere le equazioni nella forma
f (y
u
) = k
s
i
f
1/ 2
A
5/3
P
2/ 3
Q f (y
c
) =
A
3
T

Q
2
g
mentre per il metodo di Newton-Raphson necessario aggiungere le rispettive derivate
f ' ( y
u
) = k
s
i
f
1/ 2
|
5
3
A
2/3
T P
2/3

4
3
A
5/3
(1+m
2
)
1/2
P
5/ 3

f ' ( y
c
) = 3A
2
m T
2
A
3
.
La scelta su quale profondit considerare viene effettuata con la variabile moto = dati(6)
dal file dati.txt che contiene anche i dati del problema.
% Portata Q (mq/s):
2
% Base B (m):
2
% Pendenza fondo (non in %):
0.00024
% Pendenza sponde m se sezione trapezia (h/b => 1/m):
1.5
% Coefficiente di Gauckler-Strickler:
40
% Profondit a moto uniforme = 1 , Profondit critica = 0
1
Entrambe le forme sono state implementate nella function f_trap con il controllo sul numero
di elementi di ingresso con il comando nargin per discriminare il calcolo della funzione o
della sua derivata.
function f = f_trap (y, der)

% Sezione trapezia, relazione di Gauckler-Strickler
% Ingresso: y = tirante
% Uscita: valore di f in y
% nargin = numero argomenti, se maggiore di uno implica
% il calcolo del valore della derivata di f in y

load 'dati.txt';
q = dati(1); b = dati(2); pf = dati(3); m = dati(4); ks = dati(5);
moto = dati(6);

a = (b*y + m*(y.^2));
p = b + 2*y*((1+(m^2))^(1/2));
t = b + 2*m*y;
k = ks * (pf^(1/2));
13
if moto ==1
if nargin > 1
fparte1 = 5/3 * t.*a.^(2/3).*p.^(-2/3);
fparte2 = 4/3 *(1+m^2)^(1/2)*a.^(5/3).*p.^(-5/3);
f = k*(fparte1-fparte2);
else
f = ( k * (a.^(5/3)).* (p.^(-2/3)) ) - q ;
end
else
if nargin > 1
f = (3*a.^2) - (2*m*t.^(-2)*a.^3);
else
f = (a.^3)./t - (q^2)/9.8067;
end
end
Per il metodo delle iterazioni di punto fisso le equazioni si pongono nella forma
f (y
u
) = k
s
i
f
1/ 2
A
5/3
P
2/ 3
Q f (y
c
) =
A
3
T

Q
2
g
Ed implementate nella function g_trap .
function g = g_trap (y)

% Sezione trapezia, relazione di Gauckler-Strickler
% Ingresso: yi = tirante
% Uscita: valore di g in y

load 'dati.txt';

q = dati(1); b = dati(2); pf = dati(3); m = dati(4); ks = dati(5);
moto = dati(6);

p = b + 2*y*((1+(m^2))^(1/2));

if moto ==1
g = (1./(b+m*y)).*((q*p.^(2/3))/(ks*(pf^(1/2)))).^(3/5);
else
g = (1./(b+m*y)).*((q^2)*(b+2*m*y)/9.8067).^(1/3);
end
Si infine creato il programma che richiama la function f_NonLineari e stampa i risultati a
video. La function non ammette argomenti in ingresso ed in uscita presenta le soluzioni per i
vari metodi, il numero di iterazioni, il limite massimo di iterazioni e il valore della derivata
della funzione; questi ultimi due valori servono per determinare se i metodi divergono
9
.
% Risoluzione del calcolo della profondit a moto uniforme e della
% profondit critica per sezione trapezia

clear all;
[yB,iB,yiNR,iNR,f1,yiPF,iPF,iter] = f_NonLineari ();

%-------------------Stampa a video dei risultati---------------------------
load 'dati.txt';
moto = dati(6);
9 In particolare il numero di iterazioni massime per il metodo di Newton-Raphson e del punto fisso, mentre il
valore della derivata solo per il metodo di Newton-Raphson.
14
if moto == 1
fprintf (' Profondit a moto uniforme (Bisezione) = ')
fprintf ('%6.4f m - Numero di passaggi = %4i \n', yB,iB)
if iNR == iter || f1 == 0
fprintf (' Profondit a moto uniforme (Newton Raphson)= ')
fprintf ('non convergente\n')
else
fprintf (' Profondit a moto uniforme (Newton Raphson)= ')
fprintf ('%6.4f m - Numero di iterazioni = %4i \n', yiNR,iNR)
end
if iPF == iter
fprintf (' Profondit a moto uniforme (Punto Fisso) = ')
fprintf ('non convergente \n')
else
fprintf (' Profondit a moto uniforme (Punto Fisso) = ')
fprintf ('%6.4f m - Numero di iterazioni = %4i \n', yiPF,iPF)
end
else
fprintf (' Profondit critica (Bisezione) = ')
fprintf ('%6.4f m - Numero di passaggi = %4i \n', yB,iB)
if iNR == iter || f1 == 0
fprintf (' Profondit critica (Newton Raphson)= ')
fprintf ('non convergente \n')
else
fprintf (' Profondit critica (Newton Raphson)= ')
fprintf ('%6.4f m - Numero di iterazioni = %4i \n', yiNR,iNR)
end
if iPF == iter
fprintf (' Profondit critica (Punto Fisso) = ')
fprintf ('non convergente\n')
else
fprintf (' Profondit critica (Punto Fisso) = ')
fprintf ('%6.4f m - Numero di iterazioni = %4i \n', yiPF,iPF)
end
end
clear dati moto;
1.3 Risultati a moto uniforme
Dati in ingresso, file dati.txt
% Portata Q (mq/s):
2
% Base B (m):
2
% Pendenza fondo (non in %):
0.00024
% Pendenza sponde m se sezione trapezia (h/b => 1/m):
1.5
% Coefficiente di Gauckler-Strickler:
40
% Profondit a moto uniforme = 1 , Profondit critica = 0
1
Dati in ingresso, file metodi.txt
% Tolleranza:
0.0001
% Valore estremo a per metodo Bisezione:
1
% Valore estremo b per metodo Bisezione:
2
15
% Valore iniziale per metodi iterativi:
1
% Numero massimo di iterazioni:
100
Stampa a video
Profondit a moto uniforme (B) = 1.1257 m - Numero di passaggi = 14
Profondit a moto uniforme (NR) = 1.1257 m - Numero di iterazioni = 4
Profondit a moto uniforme (PF) = 1.1257 m - Numero di iterazioni = 6
Grafici
10

1 1 . 0 5 1 . 1 1 . 1 5
- 0 . 4
- 0 . 3 5
- 0 . 3
- 0 . 2 5
- 0 . 2
- 0 . 1 5
- 0 . 1
- 0 . 0 5
0
0 . 0 5
V a l o r e d i y
V
a
l
o
r
e

d
i

f

(
y
)
N e w t o n R a p h s o n
0 1 2 3 4
1
1 . 0 5
1 . 1
1 . 1 5
N u m e r o i t e r a z i o n i
V
a
l
o
r
e

d
i

y
C o n v e r g e n z a
1 1 . 0 5 1 . 1 1 . 1 5
1
1 . 0 5
1 . 1
1 . 1 5
V a l o r e d i y
V
a
l
o
r
e

d
i

g

(
y
)
P u n t o F i s s o
0 2 4 6
1
1 . 0 2
1 . 0 4
1 . 0 6
1 . 0 8
1 . 1
1 . 1 2
1 . 1 4
1 . 1 6
N u m e r o i t e r a z i o n i
V
a
l
o
r
e

d
i

y
C o n v e r g e n z a
Si evidenzia come la convergenza sia di tipo oscillante in entrambi i casi; in ogni caso risulta
fondamentale la scelta del valore iniziale.
10 Vengono presentate solo le finestre grafiche per il metodo di Newton-Raphon e del punto fisso.
16
1.4 Risultati in condizioni critiche
Dati in ingresso, file dati.txt
% Portata Q (mq/s):
2.25
% Base B (m):
2
% Pendenza fondo (non in %):
0.00024
% Pendenza sponde m se sezione trapezia (h/b => 1/m):
1.5
% Coefficiente di Gauckler-Strickler:
40
% Profondit a moto uniforme = 1 , Profondit critica = 0
0
Dati in ingresso, file metodi.txt
% Tolleranza:
0.0001
% Valore estremo a per metodo Bisezione:
0
% Valore estremo b per metodo Bisezione:
1
% Valore iniziale per metodi iterativi:
0.8
% Numero massimo di iterazioni:
100
Stampa a video
Profondit critica (B) = 0.4489 m - Numero di passaggi = 13
Profondit critica (NR) = 0.4489 m - Numero di iterazioni = 6
Profondit critica (PF) = 0.4488 m - Numero di iterazioni = 5
Grafici
11

0 . 4 0 . 5 0 . 6 0 . 7 0 . 8
0
0 . 5
1
1 . 5
2
2 . 5
3
V a l o r e d i y
V
a
l
o
r
e

d
i

f

(
y
)
N e w t o n R a p h s o n
0 2 4 6
0 . 4
0 . 4 5
0 . 5
0 . 5 5
0 . 6
0 . 6 5
0 . 7
0 . 7 5
0 . 8
N u m e r o i t e r a z i o n i
V
a
l
o
r
e

d
i

y
C o n v e r g e n z a
11 Vengono presentate solo le finestre grafiche per il metodo di Newton-Raphon e del punto fisso.
17
0 . 4 0 . 5 0 . 6 0 . 7 0 . 8 0 . 9
0 . 4
0 . 4 5
0 . 5
0 . 5 5
0 . 6
0 . 6 5
0 . 7
0 . 7 5
0 . 8
V a l o r e d i y
V
a
l
o
r
e

d
i

g

(
y
)
P u n t o F i s s o
0 2 4 6
0 . 4
0 . 4 5
0 . 5
0 . 5 5
0 . 6
0 . 6 5
0 . 7
0 . 7 5
0 . 8
N u m e r o i t e r a z i o n i
V
a
l
o
r
e

d
i

y
C o n v e r g e n z a
Si evidenzia come la convergenza sia di tipo monotona in Newton-Raphson, mentre di tipo
oscillante per il punto fisso; la differenza di comportamento rispetto il calcolo della profondit
uniforme dipende sia dalla differenza tra le due equazioni, sia dalla scelta del valore iniziale.
1.5 Problemi riscontrati
Non si sono riscontrate particolari difficolt nella implementazione dei metodi.
18
ESERCITAZIONE 3 APPROSSIMAZIONE ED INTEGRAZIONE NUMERICA
DI DATI
Si considera un insieme di coppie di dati sperimentali
( x
i
, y
i
) , i =0,1, ., m
a cui si vuole
associare una funzione
f
n
(x)
che ne descriva l'andamento.
Le classi di funzione maggiormente utilizzate si dividono in:
- polinomi algebrici di grado n f
n
(x) = a
0
+ a
1
x +.+ a
n
x
n
;
- polinomi trigonometrici di grado n e frequenza ;
- funzioni spline.
La scelta della classe si basa essenzialmente su due criteri:
- interpolazione, dove viene imposto il passaggio della funzione nei punti noti;
- regressione, in cui la funzione approssima l'andamento dei dati minimizzando una data
quantit.
Le tecniche principali che riguardano polinomi interpolanti sono il metodo dei polinomi di
Lagrange e la formula di Newton alle differenze divise, a cui si aggiungono, ancora per
l'interpolazione le funzioni Spline, mentre per la regressione il pi immediato il metodo dei
minimi quadrati.
Ora si considera lo stesso insieme di coppie di dati sperimentali
( x
i
, y
i
) , i =0, ., m

come punti di una funzione f (x) non nota che si vuole integrare; stesso scenario se la
funzione fosse nota ma complessa e quindi difficilmente integrabile.
Le tecniche di integrazione numerica, dette di quadratura, sono essenzialmente:
- procedimento di Newton-Cotes;
-
procedimento di Gauss.
Il primo metodo approssima l'integrale con la sommatoria
I =

a
b
f (x) dx =

i =0
n
o
i
f (x
i
) + R
con
a=x
0
, b=x
n
in cui la funzione
f (x
i
)
viene approssimata da un polinomio interpolante
(x) = a
0
+ a
1
x +.+ a
n
x
n
per cui
I = R+

a
b
( x) dx = R+

i =0
n
y
i
|( ba) C
i
n

con
C
i
n
= costanti di Newton-Cotes
.
In questa esercitazione si sviluppa un programma Matlab per l'approssimazione dei dati e un
altro per l'integrazione numerica degli stessi dati; in particolare, per il primo problema si
sviluppano delle function dedicate per il metodo dei polinomi di Lagrange e il metodo dei
minimi quadrati, mentre per il secondo si considera il solo procedimento di Newton-Cotes.
19
3.1 Approssimazione di dati
Si considera un generico polinomio interpolante
P
n
(x) = a
0
+ a
1
x +.+ a
n
x
n
dove n = grado del polinomio = m = numero di punti .
Nel metodo dei polinomi di Lagrange si considerano n polinomi, interpolanti ognuno di un
punto, chiamati polinomi fondamentali di Lagrange

j
(x) =

i =0
i j
n
( xx
i
)

i =0
i j
n
(x
j
x
i
)
con
i =0,1,., n
j=0,1, ., n
da cui il polinomio risultate P
n
(x) =

j=1
n
y
j

j
(x) .
Ora si considera una generica funzione approssimante
f
n
(x) = c
0
fi
0
(x) + c
1
fi
1
(x) +.+ c
n
fi
n
( x)
dove

k
(x) = generica funzione di base
.
Nel metodo dei minimi quadrati si minimizza la quantit

2
=

i=0
m
| y
i
f
n
(x
i
)
2
=

i=0
m
| y
i

k=0
n
c
k

k
( x
i
)
2
ed in particolare se considero

k
(x) = x
k
e
f
n
(x)
di grado n = 1 ottengo
f
1
(x) = A+Bx
A = y
S
xy
S
xx
x B =
S
xy
S
xx
S
xy
=

x
i
y
i
m+1
x y S
xy
=

x
i
2
m+1
x
2
Entrambi i metodi sono stati implementati attraverso l'uso di function dedicate.
function [x,y] = f_Lagrange (t, h, m, def)

% Polinomi di Lagrange
% Ingresso vettori dati t ed h
% m = numero dati
% def = definizione grafica retta
% Uscita ascissa x e ordinata y di interpolazione

x = (t(1):(t(2)-t(1))/def:t(m))';
y = zeros (length(x),1);
for k = 1:length(x)
for i = 1:m
l = 1;
for j = 1:m
20
if i ~= j
l = l*((x(k)-t(j))/(t(i)-t(j)));
end
end
y(k)= y(k) + h(i)*l;
end
end
function [x,y] = f_MinQuad (t, h, m, def)

% Minimi Quadrati
% Ingresso vettori dati t ed h
% m = numero dati
% def = definizione grafica retta
% Uscita ascissa x e ordinata y di interpolazione

tm = sum (t) / m ;
hm = sum (h) / m ;
stt = (sum(t.^2)/m)-(tm^2);
sth = (sum(t.*h)/m)-(tm*hm);

b = sth / stt;
a = hm - (b*tm);

x = (t(1):(t(2)-t(1))/def:t(m))';
y = a + x.*b;
Il corpo del programma richiama i dati assegnati e le function per il calcolo dei polinomi, e la
rappresentazione grafica.
% Approssimazione di dati
clear all;

% Distribuzione fornita
load 'h_idro5.dat'; % Lettura elementi da file
t = h_idro5(:,1); % Vettori dati in ascissa
h = h_idro5(:,2); % Vettori dati in ordinata
m = length (t); % Numero di dati
clear h_idro5;
def = 10; % numero punti in ascissa tra due dati equispaziati
% in cui si vuole definire il polinomio
%
Funzione che restituisce i valori dell'ascissa e dell'ordinata
% interpolate con i polinomi di Lagrange in base ai dati (h,t) e al
% parametro def
[xl,yl] = f_Lagrange (t, h, m, def);
%
Funzione che restituisce i valori dell'ascissa e dell'ordinata
% approssimate con i minimi quadrati in base ai dati (h,t) e al parametro
% def
[xm,ym] = f_MinQuad (t, h, m, def);
%
%---------Grafico che mette a confronto i dati con il polinomio------------
%---------------interpolante e la retta di regressione---------------------
close all;

% comandi di grafica sulla figure 1 (Lagrange)
h1 = figure; whitebg(h1, 'white'); hold on;
xlabel('Tempo in ore','fontsize',10);
ylabel('Altezza idrometrica in metri','fontsize',10);
plot (t,h,'r.');plot (xl,yl,'k-');
title ('Interpolazione con polinomi di Lagrange','fontsize',10)
21
% comandi di grafica sulla figure 2 (Minimi quadrati)
h2 = figure; whitebg(h2, 'white'); hold on;
xlabel('Tempo in ore','fontsize',10);
ylabel('Altezza idrometrica in metri','fontsize',10);
plot (t,h,'r.'); plot (xm,ym,'g-.');
title ('Regressione lineare ai minimi quadrati','fontsize',10)
clear i j;
I risultati sono espressi nei seguenti grafici.
0 5 1 0 1 5 2 0 2 5 3 0 3 5 4 0 4 5 5 0
4 0
5 0
6 0
7 0
8 0
9 0
1 0 0
1 1 0
1 2 0
1 3 0
T e m p o i n o r e
A
l
t
e
z
z
a

i
d
r
o
m
e
t
r
i
c
a

i
n

m
e
t
r
i
R e g r e s s i o n e l i n e a r e a i m i n i m i q u a d r a t i
22
0 5 1 0 1 5 2 0 2 5 3 0 3 5 4 0 4 5 5 0
4 0
5 0
6 0
7 0
8 0
9 0
1 0 0
1 1 0
1 2 0
1 3 0
T e m p o i n o r e
A
l
t
e
z
z
a

i
d
r
o
m
e
t
r
i
c
a

i
n

m
e
t
r
i
I n t e r p o l a z i o n e c o n p o l i n o m i d i L a g r a n g e
Nel primo grafico appare chiaro come il polinomio interpolante, dato l'alto numero di dati a
disposizione, presenti un andamento fortemente oscillatorio.
Nel secondo grafico la retta dei minimi quadrati non approssima in maniera adeguata la
distribuzione dei punti vista la non linearit della stessa.
Rilanciando il programma con lo stesso set di dati tra l'ora 29 e l'ora 33 ottengo i seguenti
grafici.
Appaiono risultati apprezzabili solo per il metodo dei polinomi di Lagrange, che infatti risulta
sensibile al numero di punti da interpolare da cui deriva il grado del polinomio e il suo
conseguente carattere oscillatorio.
Per il secondo grafico resta la non linearit della distribuzione.
23
2 9 2 9 . 5 3 0 3 0 . 5 3 1 3 1 . 5 3 2 3 2 . 5 3 3
5 0
6 0
7 0
8 0
9 0
1 0 0
1 1 0
1 2 0
1 3 0
1 4 0
1 5 0
T e m p o i n o r e
A
l
t
e
z
z
a

i
d
r
o
m
e
t
r
i
c
a

i
n

m
e
t
r
i
I n t e r p o l a z i o n e c o n p o l i n o m i d i L a g r a n g e
2 9 2 9 . 5 3 0 3 0 . 5 3 1 3 1 . 5 3 2 3 2 . 5 3 3
5 0
6 0
7 0
8 0
9 0
1 0 0
1 1 0
1 2 0
1 3 0
1 4 0
1 5 0
T e m p o i n o r e
A
l
t
e
z
z
a

i
d
r
o
m
e
t
r
i
c
a

i
n

m
e
t
r
i
R e g r e s s i o n e l i n e a r e a i m i n i m i q u a d r a t i
3.2 Integrazione numerica
Se si considera la funzione complessa approssimata da un polinomio di grado n = 1
(x) = a
0
+ a
1
x
si ottiene I = H
(
y
0
+y
n
2
)
+ R in cui
H = x
n
x
0
.
Se ora divido H in intervalli minori equi-spaziati h si ottiene
I =
h
2
( y
0
+ 2y
1
+.+ 2y
n1
+ y
n
) + R
nota come regola dei trapezi.
Se si considera la funzione complessa approssimata da un polinomio di grado n = 2
(x) = a
0
+ a
1
x + a
2
x
2
si ottiene
I =
H
6
( y
0
+ y
n/ 2
+ y
n
) + R
in cui
H = x
n
x
0
.
Se ora divido H in intervalli minori equi-spaziati
h = x
n/ 2
x
0
= x
n
x
n/2
= H/ 2
si ottiene
I =
h
3
| y
0
+ y
n
+ 4( y
1
+.+ y
n1
) + 2(y
2
+.+ y
n2
) + R
nota come regola di Simpson.
In presenza di una distribuzione di punti le due regole si applicano per calcolare l'area sottesa
dalla distribuzione stessa considerando:
-
per la regola dei
trapezi:
A
(
y
0
+y
1
2
+
y
1
+y
2
2
+.+
y
n1
+y
n
2
)
h ;
-
per la regola di
Simpson:
A
(
y
0
+4y
1
+y
2
6
+
y
2
+4y
3
+y
4
6
+.+
y
n2
+4y
n1
+y
n
6
)
2h .
% Calcolo dell'area sottesa da una distibuzione di punti
% Metodo dei trapezi e tecnica di Simpson
clear all;

load 'h_idro5.dat'; % Lettura elementi da file
x = h_idro5(:,1); % Vettori dati in ascissa
y = h_idro5(:,2); % Vettori dati in ordinata
n = length (x); % Numero di dati
clear h_idro5;

h = x(2)-x(1); % valori x equispaziati
%-------Calcolo area sottesa con il metodo dei trapezi---------------------
areaT = 0;
for i=1:n-1
areaT = areaT + ((1/2)*y(i)+(1/2)*y(i+1))*h;
end
24
%-------Calcolo area sottesa con il metodo di Simpson----------------------
areaS = 0;
if rem(n,2)==0 % controllo sul numero dei dati
disp ('Attenzione, numero dati pari => perdita ultimo dato nel');
disp ('calcolo con la tecnica di Simpson => Area non calcolata');
disp ('perch risultato non attendibile');
else
for i=1:2:n-2
areaS = areaS + ((1/6)*y(i)+(4/6)*y(i+1)+(1/6)*y(i+2))*2*h;
end
end
%-------Stampa risultati---------------------------------------------------
fprintf(' Numero totale punti: %3i \n',n)
fprintf(' Metodo | Punti | N | Area \n')
fprintf('Trapezi 2 1 %8.2f \n',areaT)
fprintf('Simpson 3 2 %8.2f \n',areaS)
Per il metodo di Simpson si aggiunge il controllo sul numero di dati a disposizione che deve
essere in numero dispari per avere un corretto valore calcolato.
I risultati vengono stampati a video:
Numero totale punti: 97
Metodo | Punti | N | Area
Trapezi 2 1 3601.50
Simpson 3 2 3604.00
3.3 Problematiche riscontrate
Non sono state incontrate particolari difficolt nell'implementazione dei metodi in tutte e due
le problematiche affrontate in questa esercitazione. Tuttavia, nel metodo dei polinomi di
Lagrange, l'interpretazione iniziali dei grafici ha suscitato delle perplessit sulla bont
dell'implementazione visto il notevole carattere oscillatorio del polinomio interpolante
risultante.
25
26
ESERCITAZIONE 4 MODELLO NUMERICO AI VOLUMI FINITI PER
L'INTEGRAZIONE DELLE EQUAZIONI 1D ALLE ACQUE BASSE
Si considerano le equazioni di de Saint-Venant sviluppate per il moto vario in una dimensione
e in condizioni di alveo prismatico, distribuzione idrostatica delle pressioni e sezione
rettangolare

U
t
+

F
s
=

S
dove
12

U =
(
h
Uh
)

F =
(
Uh
U
2
h+
gh
2
2
)

S =
(
0
gh (i
f
j )
)
(vettore Flussi) (vettore Sorgente)
Tali equazioni alle derivate parziali, che vengono chiamate equazioni alle acque basse, si
possono integrare e risolvere con un metodo numerico detto ai volumi finiti, che si sviluppa
essenzialmente nelle seguenti fasi:
1 - discretizzazione del dominio in volumi di controllo finiti chiamati celle
13
;
2 - integrazione delle equazioni sulle celle;
3 - assegnazione delle condizioni iniziali e al contorno;
4 - discretizzazione delle equazioni per ottenere delle equazioni algebriche;
5 - risoluzioni delle equazioni algebriche.
Una volta assegnate le variabili come cell centered si considerano

U
i
=

U
i
(t )
e

S
i
=

S
i
(t )

come valori mediati di

U e

S sulla cella i =|s

i 1/ 2
, s
i +1/2
.
Tali termini, con valori ora costanti nella cella, non variano pi in modo continuo, ma sono
discretizzate nel dominio e quindi rappresentate da gradini; per cui risultano in funzione del
solo tempo t.
Si integrano ora le equazioni sulla cella ottenendo, per un generico step temporale
t
n
(

U
i
t
)
n
+
1
s
i
(

F
i+1/ 2
n

F
i1/ 2
n
) =

S
i
n
con
s
i
= s
i +1/ 2
s
i 1/2
Si applica infine una tecnica alle differenze finite accurata al primo ordine per la derivata
temporale ottenendo lo schema numerico di integrazione
U
i
n+1
= U
i
n

t
s
i
( F
i+1/ 2
n
F
i1/ 2
n
) + t

S
i
n
.
Caratterizzante del metodo ai volumi finiti, oltre la divisione del dominio in celle finite, la
valutazione dei flussi tra le celle, o flussi intercella nelle ascisse
s
i+1/ 2
e
s
i1/ 2
.
12 Tutte le grandezze si intendono in funzione dell'ascissa spaziale s e del tempo t.
13 Le variabili possono essere assegnate ai nodi della cella (cell vertex) o al centro della cella (cell centered), il
che discrimina la scelta del volume di controllo.
27
I metodi generalmente impiegati si distinguono in
- metodi centrati: forniscono i flussi intercella partendo dai flussi nella cella:
- Godunov centrato;
- Lax-Wendroff, Lax-Friedrichs, FORCE;
- metodi up-wind: forniscono i flussi risolvendo il problema di Riemann localmente:
- soluzione di Godunov;
- solutore HLL.
In questa esercitazione si sviluppa un programma Matlab che implementi un modello
numerico ai volumi finiti per la risoluzione delle equazioni alle acque basse 1D, con
valutazione dei flussi con il solutore HLL, implementato su function dedicata.
Ulteriori considerazioni sulla valutazione del termine sorgente, sulle condizioni iniziali e al
contorno, nei paragrafi che si occupano delle function espressamente dedicate.
Il modello verr infine testato su 4 semplici problemi idraulici:
1 - moto uniforme in alveo fluviale;
2 - moto uniforme in alveo torrentizio;
3 - moto permanente in un canale che presenti un passaggio da alveo fluviale ad alveo
torrentizio;
4 - moto permanente in un canale che presenti un passaggio da alveo torrentizio ad alveo
fluviale;
4.1 Modello ai volumi finiti
Ne corpo principale del programma si effettuano le seguenti operazioni:
- caricamento dei dati contenuti in file specifici:
- file *.geo: contiene le ascisse s, le quote dei centri cella e la classe di materiale per
ogni cella;
- file *.t00: contiene le condizioni iniziali di tiranti e velocit per ogni cella riferite al
centro cella;
- file *.idr: contiene le caratteristiche dell'idrogramma riferite alla condizione al
contorno relativa;
- file *.man: contiene i numeri di Manning in funzione della classe di materiale;
- file *.inp: contiene tutte le informazioni necessarie al programma;
- calcolo delle pendenze con tecniche al primo ordine per le celle di contorno e al secondo
ordine per le celle centrali;
- risoluzione schema numerico con richiamo alle function del solutore HLL e del termine
sorgente;
- stampa grafica a video della grandezza scelta.
In particolare, nel file *.inp sono contenuti
% T = limite di tempo in secondi:
4000
% Nfq = frequenza di stampa sugli n step temporali:
50
% CN = numero di Courant:
0.8
% ccm = codice condizione di monte
301
% ccv = codice condizione di valle
-2
dove le condizioni al contorno fanno riferimento al codice descritto nel paragrafo 4.2.
28
% VOLUMI FINITI 1D

clear all; close; clc;
g = 9.80665;
%-----------Caricamento dati-----------------------------------------------
% scelta della tipologia del test (spuntando il carattere %)
%load 'modello.geo1'; % moto uniforme in alveo fluviale
%load 'modello.geo2'; % moto uniforme in alveo torrentizio
%load 'modello.geo3'; % passaggio da fluviale a torrentizio
%load 'modello.geo4'; % passaggio da torrentizio a fluviale
s = modello(:,1); z = modello(:,2); classe = modello(:,3);
load 'modello.t00'; h = modello(:,2); Uh = modello(:,3);
load 'modello.inp'; T = modello(1); Nfq = modello(2); CN = modello(3);
ccm = modello(4); ccv = modello(5);
load 'modello.idr'; idr = modello;
load 'modello.man'; man = modello;
clear modello;
%-----------Calcolo pendenze-----------------------------------------------
N = length(s);
ds = zeros (N,1); ifi = zeros (N,1);
for i=1:N
if i==1
% prima pendenza calcolata con differenza in avanti
ds(i)= s(i+1)-s(i); ifi(i)=-(z(i+1)-z(i))/ds(i);
elseif i==N
ds(i)= s(i)-s(i-1); ifi(i)=-(z(i)-z(i-1))/ds(i);
% ultima pendenza calcolata con differenza all'indietro
else
ds(i)= (s(i+1)-s(i-1))/2; ifi(i)=-(z(i+1)-z(i-1))/(2*ds(i));
% pendenze intermedie calcolate con differenze centrate
end
end
%-----------Assegnazioni iniziali------------------------------------------
i = 1; % contatore passi spaziali
n = 1; % contatore passi temporali
t = 0; % assegnazione di t0
Uht(:,1) = Uh; ht(:,1) = h; % condizioni iniziali t00
SR1L2 = zeros (N,2); % inizializzazione vettore delle
% caratteristiche massime
dt = max((Uh./h)+(g*h).^(1/2)); % primo delta t

while t < T
Uh = Uht(:,n); h = ht(:,n);
n = n+1;
for i=1:N
if i == 1
% assegnazione condizione al contorno di monte alla prima cella
[hGC,UhGC] = f_cc (ccm, h(i), Uh(i), t, idr);
[F1,SL1,SR1]=f_HLL(hGC, h(i) , UhGC, Uh(i));
[F2,SL2,SR2]=f_HLL(h(i), h(i+1), Uh(i), Uh(i+1));
SR1L2(i,:) = [abs(SR1),abs(SL2)];
elseif i == N
% assegnazione condizione al contorno di valle all'ultima cella
[hGC,UhGC] = f_cc (ccv, h(i), Uh(i), t, idr);
[F1,SL1,SR1]=f_HLL(h(i-1), h(i), Uh(i-1), Uh(i));
[F2,SL2,SR2]=f_HLL(h(i), hGC, Uh(i), UhGC);
SR1L2(i,:) = [abs(SR1),abs(SL2)];
else
[F1,SL1,SR1]=f_HLL(h(i-1), h(i), Uh(i-1), Uh(i));
[F2,SL2,SR2]=f_HLL(h(i), h(i+1), Uh(i), Uh(i+1));
SR1L2(i,:) = [abs(SR1),abs(SL2)];
end
29
% calcolo termine sorgente
S = f_Sorg(man, classe(i), h(i), Uh(i), ifi(i));
% calcolo dei termini di U
ht(i,n)=ht(i,n-1)-(dt/ds(i))*(F2(1)-F1(1));
Uht(i,n)=Uht(i,n-1)-(dt/ds(i))*(F2(2)-F1(2))+dt*S;
% controllo sulle velocit che non siano negative
if Uht(i,n)<0
Uht(i,n)=0;
end
end
% calcolo dello step temporale in funzione dello numero di Courant e
% delle massime caratteristiche
dt = CN*min(ds)/max(max(SR1L2));
t =t+dt;
%-----------Rappresentazione grafica in funione di Nq----------------------
if rem(n,Nfq)==0 || t > T
figure(1);
% Scelta se stampare a video i livelli o i tiranti
%ylabel('Livello','fontsize',10); plot(s,(z+ht(:,n)),'b-',s,z,'k-');
%ylabel('Tirante','fontsize',10); plot(s,ht(:,n),0,0,'w.',s(N),2,'w.');
title (['time=' num2str(t) ' secondi'],'fontsize',10);
pause;
end
%--------------------------------------------------------------------------
end
clear F1 F2 SL1 SL2 SR1 SR2 SR1L2;
clear I S d ds g i j;
clear UhGC hGC;
clear classe dUhidr idr ifi man;
4.2 Condizioni al contorno
Le condizioni al contorno vengono assegnate ad un cella
14
fittizia chiamata ghost cell in base
ai valori di tirante e velocit della cella precedente o successiva a seconda se la condizione
di monte o di valle; i codici a cui fare riferimento sono i seguenti:
Codice Tipologia di condizione
-1 Condizione di parete = riflessione totale
-2 Condizione cinematica = trasmissione totale
301 Condizione di flusso = assegnato idrogramma
function [hGC,UhGC] = f_cc(cc, h, Uh, t, idr)

% Funzione assegnazione condizioni al contorno
% Ingresso: cc = codice condizione al contorno
% h, Uh = tirante e velocit cella i
% t = valore step temporale
% idr = idrogramma
% Uscita: valori di tirante e velocit nella ghost cell

I = size(idr,1);
if cc == -1
hGC = h; UhGC = -Uh;
elseif cc == -2
hGC = h; UhGC = Uh;
14 Una cella perch il modello al primo ordine.
30
else
hGC = h;
for d =2:I
if t <= idr(d,1)
dUhidr = idr(d,2)-idr(d-1,2);
dtidr = idr(d,1)-idr(d-1,1);
UhGC = idr(d-1,2)+((t-idr(d-1,1))*dUhidr/dtidr);
else
UhGC=idr(I,2);
end
end
end
4.3 Solutore HLL
La tecnica up-wind tramite soluzione di Godunov risolve il problema di Riemann
nell'intercella in maniera esatta considerando, in particolare, la soluzione al punto di ascissa
locale s = 0 del problema di Stoker (wet bed) e del problema di Ritter (dry bed).
Il solutore HLL introduce, rispetto alla soluzione di Godunov, una semplificazione nella
valutazione dei flussi intercella, cio al punto di ascissa locale s = 0 .
In particolare distingue tre casi a seconda del valore della celerit destra
S
R
e della celerit
sinistra
S
L
:
S
L
> 0

F
i+1/ 2
=

F
L
=

F(

U
L
)
S
L
0 S
R

F
i+1/ 2
=

F
HLL
=
(

U
R

U
L
) S
R
S
L
+

F
L
S
R

F
R
S
L
S
R
S
L
S
R
0

F
i+1/ 2
=

F
R
=

F(

U
R
)
La stima delle celerit viene effettuata tramite la stima del tirante h * come:
h * =
1
g
|
1
2
(c
L
+c
R
)+
1
4
( U
L
U
R
)

2
se risulta
h * min( h
L
, h
R
)
h * =
h
L
.
g( h *+h
L
)
2h * h
L
+h
R
.
g (h *+h
R
)
2h * h
R
+U
L
U
R
.
g( h *+h
L
)
2h * h
L
+
.
g( h *+h
R
)
2h * h
R
altrimenti (dove come h * di primo
tentativo si utilizza la precedente)
function [F,SL,SR]= f_HLL(hL, hR , UhL , UhR)

% Solutore HLL
% Ingresso: tiranti e velocit destri e sinistri
% Uscita: vettore flussi e valori celerit
g=9.80665;

if hL == 0 && hR == 0
F = [0;0];
SL = 0; SR = 0;
elseif hL ~= 0 && hR == 0
% solutore di Ritter (fondo DRY)
[F,SL,SR]=f_Dry(hL, 0 , UhL , 0);
elseif hL == 0 && hR ~= 0
% solutore di Ritter (fondo DRY)
[F,SL,SR]=f_Dry(0, hR , 0 , UhR);
else
UL = UhL/hL;
UR = UhR/hR;
31
%-----------Solutore HLL (calcolo celerit in funzione di h*=hs)-----------
cL = (g*hL)^(1/2); cR = (g*hR)^(1/2);
hS = (((1/2)*(cL+cR)+(1/4)*(UL-UR))^2)/g;
if hS > min(hL,hR) % singola iterazione per il calcolo nel doppio shock
L = (g*(hS+hL)/(2*hS*hL))^(1/2); R = (g*(hS+hR)/(2*hS*hR))^(1/2);
hS = (hL*L+hR*R+UL-UR)/(L+R);
end
if hS > hR
qR = (hS*(hS+hR)/(2*hR^2))^(1/2); SR = UR+qR*cR;
else
SR = UR+cR;
end
if hS > hL
qL = (hS*(hS+hL)/(2*hL^2))^(1/2); SL = UL-qL*cL;
else
SL = UL-cL;
end
%-----------Solutore HLL (calcolo dei flussi a seconda del caso specifico--
FL = [(hL*UL);((UL^2)*hL+g*(hL^2)/2)];
FR = [(hR*UR);((UR^2)*hR+g*(hR^2)/2)];
UbL = [hL;UL*hL];
UbR = [hR;UR*hR];
if SL > 0
F = FL;
elseif SR < 0
F = FR;
else
F = ((UbR-UbL)*SL*SR+FL*SR-FR*SL)/(SR-SL);
end
end
Nel caso in cui uno dei due tiranti sia pari a zero si risolve un problema di Ritter che di
immediata soluzione.
function [F,SL,SR]=f_Dry(hL, hR , UhL , UhR)

% Solutore al problema di Ritter
% Ingresso: tiranti e velocit destri e sinistri
% Uscita: vettore flussi e valori celerit

g = 9.80665;

if hR ==0 % Tirante destro nullo
UL = UhL/hL;
cL = (g*hL)^(1/2);
SL = UL - cL;
SR = UL + 2*cL;
h = (1/g)*((1/3)*UL+(2/3)*cL)^2;
U = (1/3)*UL+(2/3)*cL;
F = [(h*U);((U^2)*h+g*(h^2)/2)];
else % Tirante sinistro nullo
UR = UhR/hR;
cR = (g*hR)^(1/2);
SL = UR - 2*cR;
SR = UR + cR;
h = (1/g)*((-1/3)*UR+(2/3)*cR)^2;
U = (1/3)*UR-(2/3)*cR;
F = [(h*U);((U^2)*h+g*(h^2)/2)];
end
32
4.4 Termine sorgente
Si considera il caso di sezione rettangolare infinitamente larga dove risulta
U=
1
n
M
h
2/3
j
1/2
j=
n
M
2
U
2
h
4/ 3
j
i
n
=
n
M
2
( U
i
n
)
2
(h
i
n
)
4/ 3
function S = f_Sorg(man, classe, h, Uh, ifi)

% Calcolo termine Sorgente
% Ingresso: man = numeri di Manning
% classe = classe cella i
% h, Uh = tirante e velocit cella i
% ifi = pendenza cella i
% Uscita: termine sorgente
g=9.80665;
if h==0
S = 0;
else
j = (man(classe,2))^2*(Uh/h)^2*(h^(-4/3));
S = g*h*(ifi-j);
end
4.5 Esempi applicativi
Esempio 1 b (m) Q (m
3
/s) Uh ( m
3
/s/m)
6 20 3.33
i
f
n
M
(m
-1/3
s) s (m)
0.001 0.0143 50
file *.idr
% Idrogramma
% t(s) Uh(mc/s/m)
0 3.33
10 3.33
Stampa al primo Nfq (tiranti)
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 3 1 2 . 9 8 3 9 s e c o n d i
Stampa al terzo Nfq (tiranti)
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 9 6 2 . 1 8 6 9 s e c o n d i
33
Risultato finale (tiranti) Per un valore di y = 1.2784 m
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 4 0 0 1 . 6 2 1 4 s e c o n d i
Esempio 2 b (m) Q (m
3
/s) Uh ( m
3
/s/m)
6 20 3.33
i
f
n
M
(m
-1/3
s) s (m)
0.004 0.0143 50
file *.idr
% Idrogramma
% t(s) Uh(mc/s/m)
0 3.33
10 3.33
Stampa al primo Nfq (tiranti)
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 2 8 9 . 6 2 3 8 s e c o n d i
Stampa al terzo Nfq (tiranti)
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 8 7 5 . 7 4 3 6 s e c o n d i
Risultato finale (tiranti) Per un valore di y = 0.8434 m
0 5 0 0 1 0 0 0 1 5 0 0 2 0 0 0 2 5 0 0 3 0 0 0 3 5 0 0
0
0 . 5
1
1 . 5
2
t i m e = 4 0 0 5 . 8 1 2 4 s e c o n d i
34
Esempio 3 b (m) Q (m
3
/s) Uh ( m
3
/s/m)
- 33
i
f, fluviale
n
M, fluviale
(m
-1/3
s) s (m)
0.0024 0.0500 200
i
f, torrentizio
n
M, torrentizio
(m
-1/3
s)
0.0120 0.0200
file *.idr
% Idrogramma
% t(s) Uh(mc/s/m)
0 33
10 33
Stampa al primo Nfq (tiranti)
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
2
4
6
8
t i m e = 1 1 9 7 . 6 4 4 8 s e c o n d i
Stampa al terzo Nfq (tiranti)
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
5
1 0
t i m e = 3 5 0 3 . 1 2 5 8 s e c o n d i
Risultato finale (tiranti) Per un valore di y
f
= 8.2494 m e y
t
= 2.9360 m
15
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
5
1 0
t i m e = 6 0 0 1 . 7 2 3 4 s e c o n d i
15 Il profilo risulta brusco per una deformazione di scala, infatti i profili 2f e 2t dovrebbero apparire con una
variazione pi dolce.
35
Esempio 4 b (m) Q (m
3
/s) Uh ( m
3
/s/m)
- 1.5
i
f, torrentizio
n
M, torrentizio
(m
-1/3
s) s (m)
0.015 0.0143 200
i
f, fluviale
n
M, fluviale
(m
-1/3
s)
0.003 0.0286
file *.idr
% Idrogramma
% t(s) Uh(mc/s/m)
0 1.5
10 1.5
Stampa al primo Nfq (tiranti)
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
0 . 5
1
t i m e = 1 0 2 8 . 2 7 8 7 s e c o n d i
Stampa al secondo Nfq (tiranti)
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
0 . 5
1
t i m e = 2 1 4 1 . 1 6 2 7 s e c o n d i
Stampa al quarto Nfq (tiranti)
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
0 . 5
1
t i m e = 4 7 5 3 . 7 0 1 4 s e c o n d i
Risultato finale (tiranti) Per un valore di y
t
= 0.3516 m e y
f
= 0.8636 m
0 2 0 0 0 4 0 0 0 6 0 0 0 8 0 0 0 1 0 0 0 0 1 2 0 0 0 1 4 0 0 0 1 6 0 0 0 1 8 0 0 0
0
0 . 5
1
t i m e = 7 0 0 0 . 8 4 0 7 s e c o n d i
36
4.6 Considerazioni finali
Si nota come nel moto permanente il campo di studio deve essere aumentato rispetto al moto
uniforme vista al presenza di profili di rigurgito; lo stesso vale per il tempo di raggiungimento
delle condizioni di permanenza.
Nell'implementazione del modello in Matlab le maggiori difficolt sono state rappresentate
nel direzionare l'esecuzione del programma tra i vari casi, sia per l'esatta interpretazione della
condizioni al contorno, sia all'interno del solutore. Tuttavia, per la semplicit dei casi di
studio, non ci sono riscontrate particolarit nei risultati.
37