About the author
Realizziamo un esempio sull'utilizzo di OpenFOAM per l''analisi della dinamica di un fluido all''interno di una condotta.
Ogni nuovo caso da analizzare deve essere inserito in una nuova directory realizzata appositamente, in cui saranno inseriti tutti i parametri per la simulazione.
Iniziamo realizzando la struttura base della simulazione:
- Nome
- Marco Vito Moscaritolo
- Professione
- Docente
- Istruzione
- Ingegneria Chimica
- Età
- 25
$ mkdir ~/OpenFOAM/nome utente-1.3/run/nome simulazione
$ mkdir ~/OpenFOAM/nome utente-1.3/run/nome simulazione/constant
$ mkdir ~/OpenFOAM/nome utente-1.3/run/nome simulazione/constant/polyMesh
$ mkdir ~/OpenFOAM/nome utente-1.3/run/nome simulazione/system
La prima è la cartella che raccoglie tutte le informazioni sula simulazione, la cartella constant contiene le informazioni della simulazione che non mutano nel tempo e nella sua sottodirectory polyMesh troviamo le informazioni sulla struttura (2D o 3D) del dominio in analisi. La cartella system contiene tutte le informazioni indispensabili al simulatore quali la durata del processo da considerare, l''intervallo di tempo tra due step successivi, quali informazioni salvare e ogni quanto tempo, etc...
Iniziamo a realizzare il dominio della simulazione. Questa operazione può essere svolta con numerosi programmi di preprocessing (quali gMsh, Salome, ...), oppure editando direttamente un file di testo. Per questa volta, data la semplicità della struttura, utilizzeremo quest''ultimo metodo, in una prossimo articolo affronteremo in maniera più completa la realizzazione di strutture complesse con altri programmi.
Il file conterrà le informazioni della struttura sarà:
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/constant/polyMesh/blockMeshDict
In questo file andremo ad inserire:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object blockMeshDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 0.1;
vertices
(
);
blocks
(
);
edges
(
);
patches
(
);
mergePatchPairs
(
);
// ************************************************************************* //
come si può notare non si è inserta alcuna informazioni circa la struttura, ma abbiamo creato la struttura di base da cui poi si otterranno tutte le informazioni necessarie. L''opzione convertToMeters indica quale è l''unità di misura scelta , nel nostro caso 0.1m ovvero 10cm. All''interno del blocco vertices andremo ad inserire le coordinate di ognuno dei vertici della nostra struttura secondo la tripletta (X Y Z). All''interno di blocks andremo a realizzare quali sono i vertici correlati in modo da avere dei blocchi che saranno il dnominio della simulazione, infine in patches si avranno le informazioni per indicare le pareti della struttura, ognuna caratterizzata da differenti proprietà.
La struttura che vogliamo realizzare è quì rappresentata e ogni suo vertice deve essere inserito (oltre ad alcuni vertici di supporto) così da permettere la ricostruzione esatta del dominio.
I numeri in rosso indicano i vertici posizionati a quota 0, mentre quelli in blui sono posizionati a Z=1. Iniziamo quindi inserendo:
...
...
convertToMeters 0.1;
vertices
(
(0 0 0) // Point 0
(10 0 0) // Point 1
(0 1 0) // Point 2
(5 1 0) // Point 3
(6 1 0) // Point 4
(9 1 0) // Point 5
(9 2 0) // Point 6
(6 2 0) // Point 7
(5 2 0) // Point 8
(0 2 0) // Point 9
...
...
e proseguiamo fino al ccompleto inserimento di tutti i vertici riportati.
I blocchi devono essere inseriti seguendo le specifiche riportate nel manuale di OpenFOAM, nel nostro caso utilizziamo dei parallelepiedi (per non compicare troppo le cose) quindi dovremmo inserirli come indicato:
hex (0 28 3 2 14 38 17 16 ) (10 10 10) simpleGrading (1 1 1)
dove hex indica il tipo di blocco, gli otto numeri seguenti indicano i vercii del blocco partendo da quello in posizioneinferiore a sinistra e proseguendo in senso orario, per poi passare alla faccia superiore (sempre in senso orario). La tripletta successivi indica in quanti punti deve essere suddiviso il blocco per generare la griglia di calcolo, mentre simpleGrading (1 1 1) indica il rapporto che vi è tra i vari elementi della mesh che si andrà a realizzare; nel nostro caso la mesh sarà regolare. Proseguiamo in qesto modo fino al completamento della struttura:
...
...
blocks
(
hex (0 28 3 2 14 38 17 16 ) (10 10 10) simpleGrading (1 1 1)
hex (28 29 4 3 38 39 18 17 ) (10 10 10) simpleGrading (1 1 1)
hex (29 30 5 4 39 47 19 18 ) (10 10 10) simpleGrading (1 1 1)
hex (30 1 36 5 47 15 40 19 ) (10 10 10) simpleGrading (1 1 1)
...
...
La parte finale per la generazione del dominio di calcolo è la realizzazione delle superfici al contorno (boundary), che vanno inserirte all''interno di patches, dove dovremmo indicare il tipo di boundary (se si tratta di una superficie attreverso cui il fluido può passare o meno), seguita dal nome e contenente i vertici delle pareti da considerare. Per una maggiore comprensione delle seguenti linee di codice consiglio la lettura del manuale utente, in ogni caso il risultato sarà simile a:
...
...
patches
(
// Faccia di ingresso
patch inlet
(
(0 14 16 2)
)
// Faccia di uscita
patch outlet
(
( 10 24 25 11)
)
..
...
La mesh finale ottenuta è visibile nell''immagine seguente:
Terminata la fase di realizzazione del dominio è necessario andare ad impostare le proprietà del fluido e della superficie (boundary condiction) per la simulazione. Le proprietà del fluido sono configurabili all''interno del file
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/constant/transportProperties
dove andremo ad inserire la viscosità del fluido (simuliamo solamente i fenomeni di trasporto, nessun trasporto di calore o reazioni, miscelazione di più fluidi, ...) quindi andremo a scrivere:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
lass dictionary;
object transportProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
nu nu [0 2 -1 0 0 0 0] 0.01;
// ************************************************************************* //
dove nu indica la viscosità, il successivo vettore indica gli esponenti delle unità di misura in cui è espressa infine il valore che assume; nel nostro caso abbiamo impostato le proprietà per il fluido acqua. Le informazioni sulle condizioni iniziali del fluido all''inizio della simulazione si trovano all''interno della cartella
~/OpenFOAM/nome utente-1.3/run/nome simulazione/0
ed in particolare avremo:
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/0/p
che contiene:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class volScalarField;
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField uniform 0;
boundaryField
{
inlet
{
type zeroGradient;
}
outlet
{
type fixedValue;
value uniform 0;
}
border
{
type zeroGradient;
}
}
// ************************************************************************* //
Dove si indica che sulle superfici inlet e border il gradiente di ressione è nulla, mentre sulla superficie in uscita si ha pressione costante e pari a 0, ovvero la parete non fornisce nessuna resistenza all''uscita del fluido.
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/0/U
che invece contiene:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class volVectorField;
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0]
internalField uniform (0 0 0);
boundaryField
{
inlel
{
type fixedValue;
value uniform (0.1 0 0);
}
outlet
{
type zeroGradient;
}
border
{
type fixedValue;
value uniform (0 0 0);
}
}
// ************************************************************************* //
In questo caso la velocità iniziale, espressa in m/s come indicato nella proprietà dimension, del fuido all''interno del dominio è impostata a 0 (internalField) e dalle superfici inlet il fluido entra con una velocità di 0.1m/s, mentre sulle pareti la velotà del fluido è nulla; infine sulla parete di uscita la velocità ha gradiente nullo.
Ora andremo ad impostare i paramentri per il simulatore che andremo ad utilizzare successivamente. Queste informazioni si trovano nel file
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/system/controlDict
che conterrà:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application icoFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 10;
deltaT 0.005;
writeControl timeStep;
writeInterval 20;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression uncompressed;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
// ************************************************************************* //
Dove abbiamo impostato il codice di simulazione che utilizzeremo (icoFoam), il tempo di partenza (starTime = 0s) e il termine della simulazione (endTime = 10s); il tempo trascorso tra due step della simulazione (deltaT = 0.005s), e di scrivere i risultati ogni 20 step (in pratica ogni 0.1s) infine indichiamo di salvare le informazioni in un file di testo non compresso con una precisione di 6 decimali e impostiamo la precisione del tempo a 6 decimali.
Le impostazioni per la tipologia di codice da utilizzare nella simulazione è indicata nel file:
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/system/fvSchemes
Al cui interno troveremo:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object fvSchemes;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ddtSchemes
{
default Euler;
}
gradSchemes
{
default Gauss linear;
grad(p) Gauss linear;
}
divSchemes
{
default none;
div(phi,U) Gauss linear;
}
laplacianSchemes
{
default none;
laplacian(nu,U) Gauss linear corrected;
laplacian(1|A(U),p) Gauss linear corrected;
}
interpolationSchemes
{
default linear;
interpolate(HbyA) linear;
}
snGradSchemes
{
default corrected;
}
// ************************************************************************* //
Non approfondiremo in questa sede le impostazioni riportate, che fosse interessato cosulti il manuale utente di OpenFOAM. Le iformazioni che vogliamo salvare della simulazione (quelle su cui andremo ad effettuare le aalisi che ci interessano) si trovano nel file:
$ gedit ~/OpenFOAM/nome utente-1.3/run/nome simulazione/system/fvSolution
che contiene:
/*---------------------------------------------------------------------------*\\
| ========= | |
| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\\\ / O peration | Version: 1.3 |
| \\\\ / A nd | Web: http://www.openfoam.org |
| \\\\/ M anipulation | |
\\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
root "";
case "";
instance "";
local "";
class dictionary;
object fvSolution;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
solvers
{
p ICCG 1e-06 0;
U BICCG 1e-05 0;
}
PISO
{
nCorrectors 2;
nNonOrthogonalCorrectors 0;
pRefCell 0;
pRefValue 0;
}
// ************************************************************************* //
In cui è indicato che ci interessa salvare le informazioni di pressione (p) e velocità (U) del fluido all''interno del dominio.
Potete trovare la cartella con a struttura e i file fondamentali già preparati qui.
Al termine di tute queste operazioni è possibile lanciare il processo di simulazione con il comando:
$ cd ~/OpenFOAM/nome utente-1.3/run/
$ blockMesh . nome simulazione
$ icoFoam . nome simulazione
Dove il primo comando ci porta nella directory radice della nstra simulazione, il secondo genera la mesh usando le informazioni indicate e il terzo effettua la simualzione vera e propria. Al termine dovremmo trovare all''interno della cartella nome simulazione una serie di cartelle, ognuna con il nome indicante il tempo in cui ci si trova (per esempio 3.5 indica che ci si trova a 3s e mezzo della simulazione), che contengono i file con i dati ottenuti.
$ ls ~/OpenFOAM/nome utente-1.3/run/nome simulazione/
La fase successiva sarà la visualizzazione ed interpretazione dei dati così ottenuti, per esempio tramite paraView (se installato come indicato nell''articolo precedente) tramite il comando:
$ paraFoam . nome simulazione
Immagine della velocità nella sezione centrale lungo il piano z della condotta.
Immagine della velocità del fluido nella condotta.
Post new comment