Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Flusso Sotto Traversa PDF
Flusso Sotto Traversa PDF
FACOLTÀ DI INGEGNERIA
CORSO DI LAUREA SPECIALISTICA
IN STRUTTURE ED OPERE DELL’INGEGNERIA CIVILE
Corso di
IDRAULICA II
Prof. Gianni Pedrizzetti
Anno Accademico 2005/2006
Analisi del
flusso al di
sotto di una
traversa
fluviale
Introduzione
Il presente elaborato si propone di studiare l’andamento del flusso idraulico al di
sotto di una traversa fluviale con l’ausilio di un software appositamente realizzato
che sfrutti il metodo alle differenze finite per risolvere l’equazione di Laplace.
Verranno innanzitutto presentate alcune note teoriche riguardo l’idraulica dei mezzi
porosi incomprimibili, il metodo alle differenze finite e il linguaggio di
programmazione Scilab.
Si procederà poi all’illustrazione dello script di calcolo realizzato ed allegato in calce
al presente documento, limitandosi a considerarne le particolarità e le difficoltà
incontrate.
Infine verranno presentati i risultati di alcune simulazioni effettuate con diversi
parametri di input, sulla base delle quali verranno condotte alcune osservazioni sul
fenomeno della filtrazione al di sotto delle traverse fluviali e una comparazione tra i
risultati della simulazione numerica ed i relativi metodi analitici comunemente
utilizzati nelle costruzioni idrauliche.
(1,1) x
Hi-1,j
(i-1,j)
(i+1,j)
(n,m)
Hi+1,j
Figura 1: La griglia di riferimento e la stella di Laplace del metodo alle differenze finite usati in
questo lavoro. L’asse delle ascisse è assunto positivo verso il basso al fine di poter esprimere la y
come profondità rispetto al piano campagna. La direzione degli indici i e j è stata costruita
contrariamente a quanto si fa di solito al fine di mantenere l’analogia grafica con la notazione righe
per colonne: in questo senso l’espressione (i,j) non rappresenta le coordinate cartesiane del nodo
della griglia ma la notazione matriciale dell’elemento della matrice. Solitamente si preferisce invece
rendere (i,j) come coordinata cartesiana del nodo della griglia: in questo modo l’indice di riga
corrisponde alle y e quello di colonna alle x, e la matrice che si ottiene sarà, graficamente, la trasposta
della griglia cartesiana.
Nel presente lavoro l’equazione di Laplace nelle due dimensioni è stata risolta
utilizzando il metodo alle differenze finite utilizzando una griglia regolare, in modo
da poter rappresentare il dominio come una matrice. Con riferimento alla Figura 1 la
formula di approssimazione analitica del Laplaciano:
∆, ∆, , ∆ , ∆ 4 ,
∆
∆
può essere espressa, tralasciando gli infinitesimi di ordine superiore al primo, come:
, , , , 4 ,
,
∆
e di conseguenza l’equazione di Laplace nel nodo , risulta essere:
, , , , 4 , 0
Hi-1,j Hi-1,j
Hi+1,j Hi+1,j
Il metodo iterativo di Jacobi consiste nel ricalcolare per ogni passo di calcolo
l’equazione di Laplace per il singolo nodo espressa come:
, , , ,
,
4
Va osservato che il metodo di Jacobi consente di non dover procedere in maniera
regolare da sinistra a destra e dall’alto in basso lungo il dominio: è così molto più
semplice da implementare rispetto ai metodi di Gauss-Seidel e della Successive Over
Relaxation, ma necessita di maggiori tempi di elaborazione.
Scilab
Scilab è un software per il calcolo numerico sviluppato dall’INRIA per applicazioni
di controllo di sistema e signal processing liberamente distribuito su internet con
licenza open-source. Può essere visto come un clone di Matlab, il più diffuso software
commerciale di calcolo numerico, in quanto le differenze sono minime e la filosofia di
base è la stessa.
La potenza di Matlab/Scilab sta nella semplicità di manipolazione delle matrici:
operazioni basilari come concatenazione, estrazione o trasposizione vengono
realizzate come semplici operazioni quali addizioni e sottrazioni. Un altro punto di
forza è la possibilità di realizzare complessi grafici bi- e tri-dimensionali con poche
Il modello di calcolo
Ipotesi e inputs
Considerata la valenza meramente didattica del presente lavoro, per non rendere
eccessivamente laboriosa la costruzione del modello sono state assunte alcune ipotesi
semplificative per quanto riguarda le caratteristiche fisiche e geometriche del
dominio di calcolo:
- il calcolo viene eseguito in modo indipendente dal tempo con riferimento alla
situazione stabile di regime determinata da una differenza costante dei livelli
idrici di monte e di valle;
- il terreno posto tra la traversa ed il sottostrato impermeabile è composto da un
solo materiale che viene considerato isotropo;
- il substrato permeabile è considerato orizzontale;
- lontano dalla traversa si assume una distribuzione idrostatica delle pressioni
al fine di imporre le condizioni al contorno di Dirichlet sulle pareti verticali
del dominio.
h1
x
pt
y
pi
Figura 3: Rappresentazione grafica della geometria del problema e del dominio di calcolo del
modello (in giallo). Le linee grigie rappresentano la griglia di discretizzazione, quelle verdi le zone
di frontiera con condizioni di Dirichlet, quelle rosse le zone con condizioni al contorno di Neumann.
L’input dello script di calcolo è rappresentato da un vettore i cui elementi sono, oltre
alle caratteristiche geometriche di Figura 3, la permeabilità del terreno all’acqua ed
i limiti del calcolo iterativo.
Output e grafici
Una volta terminati i calcoli, gli output della funzione sono costituiti dalla matrice
dei carichi piezometrici, dalle matrici delle componenti di velocità in ogni punto, dai
vettori delle coordinate dei nodi e da due ulteriori vettori, rappresentanti uno il
carico piezometrico alla profondità del taglione e l’altro il profilo di velocità al di
sotto del taglione.
Lo script produce poi automaticamente alcuni grafici, che risultano utili sia per avere
una chiara visione del sistema che per effettuare comparazioni con altre simulazioni:
a Ciò comporta dei problemi quando le altre dimensioni gioco non sono multipli dell’intervallo di
Risultati
Grafici prodotti dallo script
In primo luogo è stata condotta una simulazione per visualizzare la distribuzione del
carico piezometrico e le velocità di flusso al di sotto della traversa. I dati in input
utilizzati per la simulazione sono:
variabile sigla valore
lunghezza traversa l 10m
livello monte h1 5m
livello valle h2 2m
spessore taglione s 0.5m
profondità taglione pt 4m
profondità strato impermeabile pi 10m
moltiplicatore di l per larghezza di indagine b 2
permeabilità del terreno K 0.02m/s
errore ammissibile epsilon 10-4
iterazioni massime imax 105
Con i primi due grafici citati nel capitolo precedente è facile visualizzare la
variazione del carico piezometrico all’interno del dominio di calcolo:
Carico piezometrico
5.0
4
2 4.0
0
3.0
-2
2.0
-4
-6 1.0
-8
0.0
-10
0 5 10 15 20 25 30 35 40 45 50
Figura 4: Grafico “sgrayplot” del carico piezometrico. I valori sono espressi in metri.
2.1
-2
4.84 2.26
0.645
0.484
0.323
0.161
1.13
0.968
0.806
1.61
1.45
1.29
1.94
1.77 2.42
4.68
-4 3.23
4.52 4.35 4.19 4.03 3.87 3.71 3.55 3.39 2.58
3.062.9 2.74
-6
-8
-10
0 5 10 15 20 25 30 35 40 45 50
Figura 5: Grafico “contour” del carico piezometrico. I valori sono espressi in metri.
Si nota subito come il passaggio dal carico piezometrico di monte a quello di valle sia
abbastanza graduale lungo la superficie impermeabile della traversa, con delle
concentrazioni nei pressi dei punti angolosi all’inizio della traversa e agli estremi
inferiori del taglione. È quindi in questi punti che le velocità raggiungeranno i loro
massimi, come si può osservare mediante gli altri due grafici prodotti dallo script:
Velocità orizzontali
2
0.010
0
-2
-4 0.005
-6
-8
0.000
-10
0 5 10 15 20 25 30 35 40 45 50
Figura 6: Grafico “sgrayplot” della velocità orizzontale. I valori sono espressi in metri al secondo.
Velocità verticali
4
0.010
2
0 0.005
-2
0.000
-4
-6
-0.005
-8
-10
0 5 10 15 20 25 30 35 40 45 50
Figura 7: Grafico “sgrayplot” della velocità verticale. I valori sono espressi in metri al secondo. Le
velocità sono considerate positive quando rivolte verso il basso.
2 2
2
0.010
0 0
0 0.010
0.005
-2 -2
-2
0.000
0.005
-4 -4
-4
-0.005
-6 -6
-6
0.000
-8 -8 -8
28.0 29.0 30.0 31.0 28.0 29.0 30.0 31.0 28.0 29.0 30.0 31.0
Figura 8: Grafici riepilogativi delle velocità nella zona del taglione. I valori sono espressi in metri al
secondo. Le velocità verticali sono considerate positive quando rivolte verso il basso.
Presso lo spigolo di monte le velocità sono rivolte verso valle e verso il basso: dal
punto di vista teorico non è così richiesta la presenza di un taglione. Nella
configurazione visualizzata nei grafici si potrebbero avere comunque dei problemi
quando il trascinamento delle particelle fini tendesse a costipare il terreno,
determinando così un cedimento differenziale dell’opera. Nella realtà presso lo
spigolo di monte viene comunque sempre realizzato uno zoccolo di fondazione che,
innestandosi nel terreno, ingloba anche le caratteristiche di taglione.
-9
Figura 10: Schema delle forze in Con l’analisi numerica è possibile visualizzare la reale
gioco per il sollevamento del distribuzione del carico piezometrico sul lato inferiore
terreno (porzione in rosso).
2.8
2.7
2.6
2.5
30.0 30.2 30.4 30.6 30.8 31.0 31.2 31.4 31.6 31.8 32.0
Figura 11: Distribuzione del carico piezometrico al di sotto del terreno interessato dal sollevamento.
La verifica condotta con il metodo pratico risulta quindi valida almeno in prima
approssimazione, avendo cura di imporre l’aggiunta dei consueti coefficienti di
sicurezza alla condizione .
Conclusioni
Lo script di calcolo prodotto con il presente lavoro non rappresenta certo un software
utilizzabile per fini diversi dalle considerazioni svolte nel capitolo precedente: le
migliorie necessarie per un uso professionale che si dovrebbero implementare nel
codice in termini di velocità di elaborazione, di automazione negli input e output e di
definizione geometrica e fisica del dominio esulano dallo scopo di un’esercitazione
per un corso universitario.
Detto questo, il lavoro svolto è comunque risultato importante per capire il metodo
alle differenze finite, per impratichirsi con l’uso di un potente strumento come Scilab,
per studiare il fenomeno della filtrazione nei mezzi porosi e per verificare
numericamente la formula pratica del sollevamento del terreno utilizzata nell’ambito
delle costruzioni idrauliche.
function [H,U,V,x,y,yta,uta,xF,F]=GWFJAC(I)
// 1. DATI DI INPUT
// lettura caratteristiche geometriche
// prova: I=[10;5;2;.5;4;10;2;.02;1e-4;1e5]
l=I(1); // lunghezza traversa
h1=I(2); // livello monte
h2=I(3); // livello valle
s=I(4); // spessore taglione
pt=I(5); // profondità taglione
pi=I(6); // profondità strato impermeabile
b=I(7); // moltiplicatore di l per larghezza di indagine
K=I(8); // permeabilità del terreno
epsilon=I(9); //errore ammissibile
imax=I(10); //iterazioni massime
// definizione rapporti
f=l/s; // rapporto lunghezze direzione x
a=pi/pt; // rapporto lunghezze direzione y
if a==0 then,a=b,end; // campo indagine in assenza di fondo impermeabile
t1=getdate()
// 2. DEFINIZIONE DOMINIO
// definizione incrementi Dx e Dy
Dx=s/2;
Dy=Dx;
// definizione numero intervalli
n=(a*pt)/Dy;
m=((2*b+1)*l)/Dx;
fx=l/Dx;
fy=pt/Dy;
// definizione vettori x e y
x=[0:Dx:m*Dx];
y=[0:Dy:n*Dy];
// definizione punti noti
jA=b*fx+1;
jB=((b+1)*fx+1)-s/Dx;
jD=(b+1)*fx+1;
jE=(2*b+1)*fx+1;
iC=fy+1;
iF=a*fy+1;
// inizializzazione matrice
H=zeros(n+1,m+1);
// 3. CONDIZIONI AL CONTORNO
// condizioni di Dirichlet
for j=1:jA H(1,j)=h1; end;
for j=jD:jE H(1,j)=h2; end;
for i=2:iF H(i,1)=h1; end;
Page : 1
for i=2:iF H(i,jE)=h2; end;
// condizioni di Neumann: inserite nel ciclo di calcolo
// 4. CALCOLO
// definizione parametri iterazione
k=1; //valore iniziale iterazione
errmax=1;
HN=H; //matrice di nuova iterazione
//inizio loop carico piezometrico
while (k<=imax & errmax>=epsilon)
// loop primo sottodominio
for i=2:n
for j=2:jB
HN(i,j)=(H(i,j-1)+H(i,j+1)+H(i-1,j)+H(i+1,j))/4;
end;
end;
// loop secondo sottodominio
for i=iC:n
for j=jB+1:jD-1
HN(i,j)=(H(i,j-1)+H(i,j+1)+H(i-1,j)+H(i+1,j))/4;
end;
end;
// loop terzo sottodominio
for i=2:n
for j=jD:m
HN(i,j)=(H(i,j-1)+H(i,j+1)+H(i-1,j)+H(i+1,j))/4;
end;
end;
// condizioni al contorno di Neumann
for j=jA:(jB-1) HN(1,j)=(H(1,j-1)+H(1,j+1)+2*H(2,j))/4; end;
for i=2:(iC-1) HN(i,jB)=(H(i-1,jB)+H(i+1,jB)+2*H(i,jB-1))/4; end;
for j=(jB+1):(jD-1) HN(iC,j)=(H(iC,j-1)+H(iC,j+1)+2*H(iC+1,j))/4; end;
for i=2:(iC-1) HN(i,jD)=((H(i-1,jD)+H(i+1,jD))+2*H(i,jD+1))/4; end;
for j=2:(jE-1) HN(iF,j)=(H(iF,j-1)+H(iF,j+1)+2*H(iF-1,j))/4; end;
HN(1,jB)=(2*H(1,jB-1)+2*H(2,jB))/4;
HN(1,jD)=(2*H(1,jD+1)+2*H(2,jD))/4;
HN(iC,jB)=(2*H(iC,jB+1)+2*H(iC-1,jB))/4;
HN(iC,jD)=(2*H(iC,jD-1)+2*H(iC-1,jD))/4;
// matrice degli errori
for i=1:n+1
for j=1:m+1
err(i,j)=abs(HN(i,j)-H(i,j));
end;
end;
errmax=max(err);
// principale
H=HN;
k=k+1;
end;
Page : 2
end;
end;
// loop secondo sottodominio
for i=iC+1:n
for j=jB:jD
U(i,j)=(H(i,j+1)-H(i,j-1))/(2*Dx);
V(i,j)=(H(i+1,j)-H(i-1,j))/(2*Dx);
end;
end;
// loop terzo sottodominio
for i=2:n
for j=jD+1:m
U(i,j)=(H(i,j+1)-H(i,j-1))/(2*Dx);
V(i,j)=(H(i+1,j)-H(i-1,j))/(2*Dx);
end;
end;
// loop al contorno
for j=2:jA U(1,j)=(H(1,j+1)-H(1,j-1))/(2*Dx); V(1,j)=(H(2,j)-H(1,j))/Dx;
end;
for j=jD+1:jE-1 U(1,j)=(H(1,j+1)-H(1,j-1))/(2*Dx); V(1,j)=(H(2,j)-H(1,j)
)/Dx; end;
for j=jA+1:jB-1 V(1,j)=0; U(1,j)=(H(1,j+1)-H(1,j-1))/(2*Dx); end;
for j=jB+1:jD-1 V(iC,j)=0; U(iC,j)=(H(iC,j+1)-H(iC,j-1))/(2*Dx); end;
for j=2:m V(iF,j)=0; U(iF,j)=(H(iF,j+1)-H(iF,j-1))/(2*Dx); end;
for i=2:n V(i,1)=(H(i+1,1)-H(i-1,1))/(2*Dx); U(i,1)=(H(i,2)-H(i,1))/Dx;
end;
for i=2:n V(i,jE)=(H(i+1,jE)-H(i-1,jE))/(2*Dx); U(i,jE)=(H(i,jE)-H(i,jE-
1))/Dx; end;
for i=2:iC U(i,jB)=0; V(i,jB)=(H(i+1,jB)-H(i-1,jB))/(2*Dx); end;
for i=2:iC U(i,jD)=0; V(i,jD)=(H(i+1,jD)-H(i-1,jD))/(2*Dx); end;
U(iC,jB)=(H(iC,jB+1)-H(iC,jB-1))/(2*Dx);
U(iC,jD)=(H(iC,jD+1)-H(iC,jD-1))/(2*Dx);
//velocità reali
U=-K*U;
V=-K*V;
// massimi e minimi
minU=min(U);
maxU=max(U);
minV=min(V);
maxV=max(V);
xF=[(jD-1)*Dx:Dx:(jD-1)*Dx+pt/2];
F=H(iC,jD-1:1:jD-1+pt/2/Dx);
t2=getdate();
dt=etime(t2,t1);
disp(dt, "Tempo di elaborazione:");
disp(k, "Iterazioni svolte:");
disp(errmax, "Errore massimo per H:");
// 5. VISUALIZZAZIONE RISULTATI
// estremi traversa
xt=[b*l,b*l,(b+1)*l-s,(b+1)*l-s,(b+1)*l,(b+1)*l];
yt=[h1,0,0,-pt,-pt,h2];
Page : 3
isoview(0,(2*b+1)*l,-pi,h1);
xset("colormap",jetcolormap(100));
Sgrayplot(x,-y,H', strf="011", rect=[0,-pi,(2*b+1)*l,h1+1]);;
colorbar(0,h1);
xpoly([0,b*l],[h1,h1]); hdl=get("hdl"); hdl.thickness=3; hdl.foreground=30
;
xpoly([(b+1)*l,(2*b+1)*l],[h2,h2]); hdl=get("hdl"); hdl.thickness=3; hdl.f
oreground=30;
xfpoly(xt,yt,1); hdl=get("hdl"); hdl.thickness=2; hdl.background=-2;
title("Carico piezometrico");
Page : 4
xfpoly(xt,yt,1); hdl=get("hdl"); hdl.thickness=2; hdl.background=-2;
title("Rappresentazione vettoriale");
subplot(132);
isoview((b+1)*l-4*s,-2*pt,(b+1)*l+3*s,h2+1);
Sgrayplot(x,-y,U', strf="011", rect=[(b+1)*l-4*s,-2*pt,(b+1)*l+3*s,h2+1]);
colorbar(minU,maxU);
xpoly([(b+1)*l,(2*b+1)*l],[h2,h2]); hdl=get("hdl"); hdl.thickness=3; hdl.f
oreground=30;
xfpoly(xt,yt,1); hdl=get("hdl"); hdl.thickness=2; hdl.background=-2;
title("Velocità orizzontali");
subplot(133);
isoview((b+1)*l-4*s,-2*pt,(b+1)*l+3*s,h2+1);
Sgrayplot(x,-y,-V', strf="011", rect=[(b+1)*l-4*s,-2*pt,(b+1)*l+3*s,h2+1])
;
colorbar(minV,maxV);
xpoly([(b+1)*l,(2*b+1)*l],[h2,h2]); hdl=get("hdl"); hdl.thickness=3; hdl.f
oreground=30;
xfpoly(xt,yt,1); hdl=get("hdl"); hdl.thickness=2; hdl.background=-2;
title("Velocità verticali");
endfunction;
Page : 5