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:
$ mkdir ~/OpenFOAM/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>
$ mkdir ~/OpenFOAM/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/constant
$ mkdir ~/OpenFOAM/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/constant/polyMesh
$ mkdir ~/OpenFOAM/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/systemLa 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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/constant/transportProperties<br />
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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/0
ed in particolare avremo:
$ gedit ~/OpenFOAM/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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<br /> {
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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/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;<br /> 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/<strong>nome utente</strong>-1.3/run/
$ blockMesh . <strong>nome simulazione</strong>
$ icoFoam . <strong>nome simulazione</strong>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/<strong>nome utente</strong>-1.3/run/<strong>nome simulazione</strong>/
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:
<br />$ paraFoam . <strong>nome simulazione</strong>
L'utilizzo di paraFoam per le operazioni di postprocessing verranno affrontate in un altro articolo, in ogni caso eccovi alcune delle immagini ottenute dalla nostra simulazione.

Immagine della velocità nella sezione centrale lungo il piano z della condotta.

Immagine della velocità del fluido nella condotta.
| Allegato | Dimensione |
|---|---|
| Test | 2.23 KB |
Commenti
Problema con fvSchemes
Ciao, ho provato a utilizzare il tuo codice di test ma quando lancio
icoFoam . SRV01ottengo un fatal error:--> FOAM FATAL IO ERROR : keyword laplacian((1|A(U)),p) is undefined in dictionary "/home/svasi/OpenFOAM/svasi-1.4/run/SRV01/system/fvSchemes::laplacianSchemes"file: /home/svasi/OpenFOAM/svasi-1.4/run/SRV01/system/fvSchemes::laplacianSchemes from line 43 to line 45.
From function dictionary::lookupEntry(const word& keyword) const
in file db/dictionary/dictionary.C at line 146.
FOAM exiting
E' il primo utilizzo di OpenFoam e non riesco a risolvere il problema.
Grazie per l'aiuto che vorrai darmi.
Ciao
Che versione di OF stai
Che versione di OF stai cercando di utilizzare? Questi esempi erano stati realizzati per la 1.3, con la 1.4.1 (l'attuale e la 1.5 in sviluppo) ci sono delle cose da cambiare, prova a vedere come è strutturato il file in questione che trovi nella cartella tutorials/icoFoam/cavity/system/fvSchemes e apporta le giuste modifiche, se proprio non ne vieni fuori fai un colpo (potrei dirti come fare, ma si impari di più a provare e cercare di capire come mai non funziona, fidati ;))
Ciao
Mavimo
PS: inizia facendone una copia pari pari ;)
Primi Passi
Ciao scusami se ti rompo ma sono uno studente di Aerospaziale che da qualche giorno ha scoperto il tuo sito (complimenti veramente ben fatto), ti ho già scritto infatti sull'argomento wireless.
Ti disturbo ancora perchè mi sono inoltrato in un lavoro di tesi con OpenFOAM, quindi ho installato seguendo il tuo bellissimo tutorial la versione 1.4 e ho provato a lavorarci su. Ho seguito questo tuo primo esempio alla lettera ma al momento della creazione della mesh mi da come errore:
Reading block mesh description dictionary--> FOAM FATAL IO ERROR : keyword version is undefined in dictionary "/home/simulatore/OpenFOAM/simulatore-1.4/esempio1/constant/polyMesh/blockMeshDict"
file: /home/simulatore/OpenFOAM/simulatore-1.4/esempio1/constant/polyMesh/blockMeshDict
From function dictionary::lookupEntry(const word& keyword) const
in file db/dictionary/dictionary.C at line 146.
FOAM exiting
sai dirmi dove e cosa ho sbagliato?
Io sono alle prime armi con linux e alle primissime con Ubuntu (ho usato Red Hat e Mandrake ma per un paio d'anni al max) quindi ti chiedo in anticipo scusa se non sarò subito molto ricettivo ai suggerimenti.
Ti ringrazio in anticipo per la pazienza e la disponibilità.
Ciao,
per quanto riguarda al wireless non ti ho risposto perché non possiedo il tuo modello e sinceramente non saprei aiutarti, per quanto riguarda il tuo problema attuale credo che sia dovuto a come hai scritto il file blockMeshDict, magari per qualche motivo hai scritto o copiato qualche carattere errato, hai provato scaricando i file che trovi allegati e ad usare quelli? Nel caso il problema sia quello potresti postare l'intero contenuto del file in questione?
Ciao
Mavimo
2D airfoil & wall functions
Scusa se l'argomento non è pertinente ma non sapevo dove altrimenti scrivere!
Sto studiando il flusso viscoso turbolento attorno ad un profilo 2D e volevo sapere come attivare e disattivare le wall function e quali condizioni al contorno dare sul profilo per k, epsilon od omega a seconda che le abbia attivate o no.
Ultima domanda sai come si risolve la transizione? Esistono dei modelli in OpenFOAM che la risolvere oppure dobbiamo conoscerla da un altro programma (per esempio Xfoil) e una volta noto come procedo?
Scusa se l'argomento non è
Scusa se l'argomento non è pertinente ma non sapevo dove altrimenti scrivere!
Potresti provare sul forum ufficiale, anche se in questi giorni latita un pò visto che sono quasi tutti a Zagabria :D
Sto studiando il flusso viscoso turbolento attorno ad un profilo 2D e volevo sapere come attivare e disattivare le wall function e quali condizioni al contorno dare sul profilo per k, epsilon od omega a seconda che le abbia attivate o no.
Che risolutori stai utilizzando? In ogni caso prova a cercate nella cartella tutorials, dovresti trovare un esempio di quello che chiedi tu. Ora non ricordo il nome esatto, ma c'è :D
Ultima domanda sai come si risolve la transizione?
In che senso? Se imposti le condizioni iniziali con moto nullo e lo fai investire da un flusso con una certa velocità automaticamente ti risolve la transizione; l'unica cosa bisogna stare attenti perché se si creano dei punti particolari, sopratutto nelle fasi iniziali della transizione in cui la soluzione diverge...
Ciao
Intanto grazie per avermi
Intanto grazie per avermi risposto. Ho provato a scrivere sul forum ufficiale ma è da un po che aspetto una risposta e allora ho provato qui, anche perche mi servivano queste info per un lavoretto piuttosto urgente (studio al poli di milano).
Per quanto riguarda il risolutore uso simpleFoam per risolvere il caso stazionario e volevo vedere cosa cambiava attivando o meno le wall function. Ho cercato nei tutorial ma non mi sembra di aver trovato un esempio con wall function disattivate.
Comunque il problema che mi interessa di piu è la transizione. Se imposto le condizioni iniziali nulle ( uniform (0 0 0) sulla velocità nel campo ) ottengo una soluzione sbagliata con simpleFoam. Per fargli capire che c'è una parte laminare devo agire anche sul turbulenceProperties, ad esempio mettendo turbulence off ma specificando comunque un modello per la turbolenza oppure no?
Intanto grazie per avermi
Intanto grazie per avermi risposto. Ho provato a scrivere sul forum ufficiale ma è da un po che aspetto una risposta e allora ho provato qui, anche perche mi servivano queste info per un lavoretto piuttosto urgente (studio al poli di milano).
Ciao, figurati, quando posso lo faccio volentieri! Quindi anche tu del poli.. collega ;) Che studi di bello?
Per quanto riguarda il risolutore uso simpleFoam per risolvere il caso stazionario e volevo vedere cosa cambiava attivando o meno le wall function. Ho cercato nei tutorial ma non mi sembra di aver trovato un esempio con wall function disattivate.
Ok, simpleFoam è un risolutore abbastanza completo, ora vorrei capire cosa intendi con attivare le wall function. Quando setti le pareti (wall) puoi andare ad impostare diverse caratteristiche (velocità al contatto, T, ...), se non vuoi avere nessun topo di attrito (caso IMHO molto particolare) potresti usare un tipo di superficie diversa da wall, ma probabilmente non ho capito la tua richiesta.
Comunque il problema che mi interessa di piu è la transizione. Se imposto le condizioni iniziali nulle ( uniform (0 0 0) sulla velocità nel campo ) ottengo una soluzione sbagliata con simpleFoam. Per fargli capire che c'è una parte laminare devo agire anche sul turbulenceProperties, ad esempio mettendo turbulence off ma specificando comunque un modello per la turbolenza oppure no?
Per quanto riguarda la soluzione del transitorio il fatto di usare una condizione iniziale nulla e successivamente inserire un flusso può creare dei problemi al risolutore, potresti lanciare un risolutore "meno sensibile" alle perturbazioni per fargli effettuare gli step iniziali, e poi far proseguire il tutto con simpleFoam. Cerca sul forum che c'erano dei post che spiegavano in che ordine usare i risolutori proprio per dei transitori particolari. A parte l'utilizzo di un risolutore differente per gli step iniziali in che senso non ottieni la soluzione sbagliata? Non converge, i risultati sono leggermente differenti o completamente errati?
Se il tuo caso è laminare (e quindi non hai turbolenza) come mai usi simpleFoam? Forse non ho capito come è strutturato il tuo caso (hai una parte turbolenta e una laminare?), se magari provi a spiegare meglio come è strutturato..
Per quanto riguarda il turbolencePropriertis off mi sembra che tu debba specificare comunque un modello da utilizzare (per esempio il solito k/epsilon).
Per quanto riguarda le wall
Per quanto riguarda le wall function era solo un mio sfizio. So che abilitando le wall function si puo evitare di entrare con la mesh nel substrato viscoso, limitandosi a risolvere la regione logaritmica. Nel caso in cui non fossero attivate ci sarebbe la necessità di infittire la mesh ed ero curioso di valutare la differenza tra i risultati.
A parte questo il vero problema è la transizione. Sto risolvendo un flusso 2D stazionario attorno ad un NACA 0012 con Re=6*10^6. In questo regime lo strato limite è inizialmente laminare ma incontra una transizione a turbolento intorno ad x=40%corda. Dato che so che molti software (come fluent ad esempio) non hanno metodi per la soluzione della transizione (risolvendo così uno strato limite completamente turbolento e sbagliando necessariamente il Cd) , mi chiedevo come si potesse risolvere il problema con OpenFoam. Ho cercato sul forum ma pur avendo trovato topic sulla transizione non ho trovato la soluzione al mio caso.
Un attimo, tu stai usando un
Un attimo, tu stai usando un rislutore per fluido non newtoniano e non comprimibile, ma in che fluido è immesso il profilo alare?
Se è come credo io si tratta di aria e dubito fortemente che tu possa ottenere risultati coerenti essento un fluido facilmente comprimibile, quindi dovresti provare con tutt'altro tipo di risolutore, in particolare prova con sonicTurbFoam, che è un risolutore adatto a transitori per flussi sub e supersonici di fluidi compimibili (per esempio l'aria).
Se, invece, effettivamente consideri il tuo fluido incomprimibile (quindi si tratta di acqua?) devi usare turbFoam, un risolutore adatto a risoluzione di transitori di fluidi incompressbili con turbolenza.
Se al termine ti va di scrivere qualche riga sul tuo problema sarò ben felice di aggiungerla alle altre guide che trovi qui (ovviamente attribuendotene la proprietà).
Da quello che ho capito
Da quello che ho capito leggendo in giro (forum di OpenFoam), il solver simpleFoam e un risolutore per casi stazionari e risolve flussi laminari/turbolenti di fluidi Newtoniani o non in regime incomprimibile (diversamente da quanto scritto sul manuale!). Per quanto riguarda turbFoam , è un solver non stazionario per questo non adatto alla mia simulazione (credo?!). Per adesso ho provato con simpleFoam a fare un po di simulazioni a basso Re (325'000) sia con modello laminare che con modelli di turbolenza. Nonostante con la turbolenza il Cf sia maggiore (come è lecito aspettarsi) rispetto al caso laminare , i Cp tornano e combaciano con i valori forniti da Xfoil. Ora volevo iniziare le simulazioni a Re=6*10^6 (sempre incomprimibile in aria, visto che la velocità è di 90 m/s) ma in questo caso lo strato limite è parte laminare e parte turbolento; così se scelgo un modello laminare non converge , mentre se scelgo un modello di turbolenza vedo uno strato limite tutto turbolento , sbagliando l'andamento del Cf e il Cd.
Scusa se tardo...
...a risponderti, ma mi ero perso la tua risposta ;)
Forse non ho capito il tuo problema, tu non stavi parlando di un transitorio (in termini di t) del flusso? per questo motivo devi usare turbFoam. Per quanto riguarda il fatto di avere un pezzo con flusso laminare e uno turbolento ora non ricordo dove, ma vi era un risolutore apposito (o meglio mi sembra fosse l'integrazione del risolutore laminare e turbolento), forse era sul Wiki o forse sul Forum, hai già provato a cercare? Sinceramente non ho mai provato ma non credo che non sia mai stato realizzato/implementato, quindi probabilmente basta cercare, altrimenti mi sa che o usi quelli già pronti (con i limiti che hanno) o inizi a integrare i due risolutori (turbolento e laminare) tra di loro, ma ti avviso che non è un'operazione banale.
Lezione su OpenFoam
Buongiorno. Lavoro al Politecnico di Milano e ho una certa esperienza di programmazione in C/C++ con i compilatori Borland, prima in ambiente DOS e DOS extended poi in ambiente Windows.
Da poco ho cominciato ad usare Linux per i vantaggi che offre, soprattutto nel campo del calcolo scientifico, e mi sono imbattuto in OpenFOAM.
Ho letto l'interessantissima lezione pubblicata in questo sito e desidererei contattare l'autore, che ha dimostrato un'invidiabile competenza,
per ricevere un supporto da principiante, in cambio di altro supporto nelle materie di mia competenza e/o a pagamento.
L'autore della nota può contattarmi all'indirizzo privato micheman@clarence.com, preferibile all'indirizzo ufficiale che è sempre
intasato dalla spazzatura.
E' possibile incontrarsi al Politecnico di Milano.
Grazie, complimenti e cordiali saluti
Lezioni in OpenFOAM
Ciao, anche io sono del poli (se non si fosse capito). Di programmazione (C/C++) ho conoscenze non proprio avanzate (per me sufficienti per quello che faccio) e non mi considero propriamente un'esperto di OpenFOAM, ma se servisse una mano sono ben disposto a darla, dipende da cosa richiedi.
Invia nuovo commento