zzOPENFOAM PDF

Initiation à la CFD open-source avec le
code OpenFOAM®
-
Tome I : Présentation générale du code,
premières simulations et premiers
programmes
-
Cyprien Soulaine
(cyprien.soulaine@gmail.com)
Toulouse
27 et 28 mars 2013
Version 3.05
Objectifs
• Connaitre les possibilités du code OpenFOAM®
• Savoir trouver de l’aide

Initiation à OpenFOAM®
• Savoir lancer et post-traiter un calcul à partir des tutoriaux existants
• Lancer un calcul en adaptant les tutoriaux à son propre cas
• Savoir décrypter un solveur pour identifier le plus adapté à sa situation
• Créer son propre solveur en modifiant un solveur existant
• Oser se lancer dans l’aventure OpenFOAM® …
Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 2

Présentation de la plateforme OpenFOAM®
Qu’est ce qu’OpenFOAM ?
OpenFOAM : programmation des équations
Où trouvez de l’aide et de la documentation ?
Premières simulations avec OpenFOAM®

Structure générale d’un cas OpenFOAM®
Exercice n°1 : Diffusion de la chaleur
Exercice n°2 : Cavité entrainée
Exercice n°3 : Ecoulement de Poiseuille
Exercice n°4 : Ascension d’une bulle (VoF)
Programmer des équations avec OpenFOAM®

Structure générale d’une application
Exercice n°5 : Ajout d’une équation de transport de chaleur dans icoFoam
Exercice n°6 : Température dans cavité entrainée
Transfert en milieu poreux avec OpenFOAM®

Exercice n°7 : Créer un solveur « Darcy »
Exercice n°8 : Température dans un milieu poreux
Exercice n°9 : Personnaliser des conditions aux limites
Exercice n°10 : Modèle à deux températures





Qu’est ce qu’OpenFOAM® ?
= Open Field Operation and Manipulation

- Résout les équations aux dérivées partielles par la méthode des volumes finis
- Code multi-physique principalement orienté vers la mécanique des fluides
- Prise en compte par défaut des géométries 3D
- Code open-source développé en C++ (programmation orientée objets)
- Téléchargeable gratuitement sur www.openfoam.com
- Conçu comme une boite à outils « facilement » programmable
- Modules de calcul-parallèle
- Installation multi-plateforme (préférence Linux)
1989 : Début du développement à l’Imperial College London

1996 : Première version de FOAM
2004 : OpenFOAM distribué sous license GPL par OpenCFD Ltd.
2013 : version 2.2.0 ; rachat de OpenCFD par ESI Group
La boîte à outils OpenFOAM®
OpenFOAM® = plus de 200 programmes (pas seulement 1 exécutable)
Préprocesseurs :
- Mailleur (blockMesh, snappyHexMesh…)

- Convertisseur de maillage (Ansys, Salomé, ideas, CFX, Star-CD, Gambit, Gmsh…)
Solveurs :
- écoulement incompressible / compressible
- écoulement multiphasique
- combustion, électromagnétique, structure
- transfert de chaleur
- plusieurs approches de turbulence (DNS, RANS, LES)
- etc…
post-traitement :
- livré avec ParaView (et l’utilitaire paraFoam)
- exportation vers d’autres plateformes de post-traitement (Fluent, Fieldview, EnSight…
- Utilitaire « sample » pour l’échantillonnage 1D ou 2D (export vers gnuplot, Grace/xmgr et jPlot)

Exemples de simulations
openfoam.com
openfoam.com
openfoam.com

OpenFOAM® : programmation des équations
Le champ considéré peut-être scalaire, vectoriel ou tensoriel

La discrétisation des opérateurs est précisée lors du lancement de la
simulation
Ecriture des équations très proche de la formulation mathématique
Où trouver de l’aide et de la documentation ?
2 guides officiels par OpenCFD (« user guide » et « programmer guide » )

(Documentation souvent insuffisante)
Plusieurs thèses fondatrices (Hrvoje Jasak 1996, Henrik Rusche 2001, …)
Un tutorial par solver. Il a souvent valeur de cas-test (Validation non-disponible

publiquement)
Accès direct au code-source (attention, le code est peu annoté !!)
En payant un support auprès d’OpenCFD Ltd, Wikki Ltd,….
Communauté active !
- Forum d’entraide (www.cfd-online.com/Forums/openfoam/)
- Un wiki (openfoamwiki.net)
- un Workshop annuel (8ème édition en 2013) (www.openfoamworkshop.org)
- Projet de travail collaboratif dirigé par 2 des développeurs orignaux
(www.extend-project.de)

OpenFOAM à l’IMFT ? (intranet de Cosinus)

Quels avantages / inconvénients ?
• Gratuit (pas de limitations dues aux licences), • Temps de prise en main,

• Accès aux sources (pas une “boîte noire”), • La documentation !!
• Un outil supplémentaire pour les benchmarks code- • Pas d’interface graphique,
to-code,
• Commandes unix et C++,
• Bénéficie de mises à jour régulières,
•…..
• De nombreux solveurs “clé en main”,
• Facilité pour programmer des équations,
• Une communauté réactive (forum, congrès,
université d’été…),
• …..


Exercice n°4 : Ascension d’un bulle (VoF)



Structure générale d’un cas OpenFOAM
$ cd ~
$ mkdir -p $FOAM_RUN
Paramétrage du calcul (choix des solvers, des schémas

de discrétisation, du pas de temps, des sorties
fichiers…)
Toutes valeurs constantes pendant le calcul (Propriétés

du transport, des modèles de turbulence, de
thermodynamique…etc)
Contient les informations relatives au maillage
Un répertoire par pas de temps. Chaque répertoire

contient autant de fichier que de champs calculés
(T,U,p, Yi, k, Omega…)
L’initialisation du calcul se fait via un répertoire « 0 »

Exercice n°1 : Diffusion de la chaleur (1/4)
Tini = 273K Exemple issu des tutoriaux livrés

avec OpenFOAM
273K
Géométrie et maillage générés
avec Ansys
Conversion avec l’utilitaire
ansysToFoam
Résolution de l’équation de la
chaleur
Solver : laplacianFoam
573K

$ run ¶
$ cp –r $FOAM_TUTORIALS/basic/laplacianFoam/flange Exo1 ¶
$ cd Exo1 ¶
$ ls ¶
$ gedit 0/T ¶
Conditions initiales et conditions aux limites

pour le champ T
Maillage : faces, points… défini plus loin
avec ansysToFoam
Valeur du coefficient de diffusion (m2/s)
Paramètres du calcul (pas de temps, sorties

fichiers…)
Schémas de discrétisation des différents
opérateurs (div, laplacian, ddt, grad…)
Paramètres et choix des solveurs linéaires
Scripts pour lancer automatiquement le tuto et
nettoyer le répertoire
Maillage créé avec Ansys

Exercice n°1 : Diffusion de la chaleur (3a/4)
Définition des conditions initiales
et des conditions à la limite
Dimensions du champ T
[kg m s K kgmol A cd]
Température initiale uniforme (T=273K)

à l’intérieur du solide
Condition à aux limites à t=0s
Flux nul
Valeur fixe (T=273K)
Valeur fixe (T=573K)

Exercice n°1 : Diffusion de la chaleur (3b/4)
$ gedit constant/transportProperties ¶

Exercice n°1 : Diffusion de la chaleur (3c/4)
$ gedit system/controlDict ¶

Conversion du maillage :
Création de fichiers dans le
$ ansysToFoam flange.ans –scale 0.001 ¶
répertoire polyMesh
Visualisation du maillage dans paraView
$ paraFoam ¶
Lancement de la simulation Création d’un répertoire / pas de

temps
$ laplacianFoam ¶
Visualisation du résultat dans paraView

$ paraFoam ¶
4 - Choix du
champ à 5 - Pour lire
visualiser l’ensemble des
pas de temps
3- Choisir
« surface »
2 - « apply » Exo1bis :
DT = 1e-3 m²/s
Jusqu’à l’état
stationnaire
1 - Choix des
champs à
visualiser
Exercice n°2 : Cavité entrainée (1/6)
Ux=1m/s Tutorial détaillé dans le User Guide
movingWall
Création de la géométrie et du maillage

avec l’utilitaire BlockMesh
fixedWalls
fixedWalls
Résolution de Navier-Stokes incompressible
en régime laminaire (solver icoFoam)
y
fixedWalls
x
Post-traitement avec ParaView
$ run ¶
$ cp –r $FOAM_TUTORIALS/incompressible/icoFoam/cavity Exo2 ¶
$ cd Exo2 ¶
$ ls ¶
BlockMesh = utilitaire de prétraitement pour les géométries simples
Géométrie et maillage définis dans le fichier blockMeshDict
Définition des points
$ gedit constant/polyMesh/blockMeshDict ¶
Définition de la géométrie en 3D car OpenFOAM n’accepte
que des géométrie 3D

3 2
Définition du bloc hexa
7 6
Définition du maillage (Maillage y z

homogène, 1 seule maille dans 0
la direction z pour calcul 2D) x 1
4
5
Définition des bords de la Attention l’ordre de numérotation des points est important !!
géométrie (« patches »)
pour application des On précise que le calcul est 2D
conditions aux limites.
Les patches peuvent être de plusieurs types :
Les faces orthogonales a -patch (type générique)
l’axe Oz sont « vides » -wall (pour les conditions de mur, utile pour la turbulence)
pour préciser que le -cyclic (pour les conditions périodiques)
calcul est 2D
-symmetryPlane (pour les plans de symétrie)
-empty (pour revenir à des géométries 2D ou 1D)
-wedge (pour les géométries axi-symmétrique)
-processor (pour le calcul parallèle)
Exécution de blockMesh : $ blockMesh¶
Contrôle du maillage : $ checkMesh¶
Visualisation du maillage : $ paraFoam¶
6 – Edit>view Setting>use Parallel Projection
4 - « Apply » 5 - « wireframe »
2 – Visualiser
le nom des
patch sur la
géométrie
1 - Choix des
parties à visualiser

Exercice n°2 : Cavité entrainée (4a/6)
$ gedit constant/transportProperties &¶
On est donc bien en régime

laminaire

Exercice n°2 : Cavité entrainée (4b/6)
$ gedit 0/U¶

Exercice n°2 : Cavité entrainée (4c/6)
$ gedit 0/p¶
Attention aux unités, ici,

Exercice n°2 : Cavité entrainée (4d/6)
$ gedit system/controDict¶
Gestion de la discrétisation en
temps (début, fin, pas de temps)
Gestion des sorties fichiers

Lancement du calcul :
$ icoFoam ¶
Post-traitement avec ParaView : $ paraFoam ¶

Exercice n°2 : Cavité entrainée (6a/6)
Pour visualiser les vecteurs « vitesse »
On précise que l’on choisit les valeurs

au centre des cellules avec le filtre
CellCenter :
filters>alphabetical>CellCenter>Apply
On applique ensuite le filtre Glyph pour

tracer les vecteurs vitesses:
filters>alphabetical>Glyph>Properties
apply
Exercice n°2 : Cavité entrainée (6b/6)
Pour visualiser les vecteurs « vitesse »
Display> color by > U

Exercice n°3 : Ecoulement de Poiseuille (1/4)
Objectifs :
Simuler un écoulement de Poiseuille dans un tube (2D) , avec condition de symétrie
Résolution de Navier-Stokes incompressible en régime laminaire (solver icoFoam)

symmetryPlane
outlet
inlet
y bottomWall
x
$ run ¶
$ cp –r $FOAM_TUTORIALS/incompressible/icoFoam/cavity Exo3 ¶
$ cd Exo3 ¶
symmetryPlane
3 2
inlet 7 outlet
6
y z 0
x 1
4
bottomWall
$ blockMesh¶
Exercice n°3 : Ecoulement de Poiseuille (3a/4)
$ gedit 0/U¶

Exercice n°3 : Ecoulement de Poiseuille (3b/4)
$ gedit 0/p ¶

On garde les mêmes paramètres de calcul que ceux de l’exercice 2
Lancement du calcul : $ icoFoam ¶
Visualisation du résultat : $ paraFoam¶
1 – Filters>Data Analysis>Plot Over Line
3 – Désélectionner la
visualisation du champ de
pression p
2 – On va tracer le profil de vitesse le

long de l’axe y au milieu du tube

Exercice n°4 : Ascension d’une bulle (1/5)
Objectifs :
Simuler l’ascension d’une bulle dans une colonne
d’eau
Exercice adapté du tutoriel damBreak détaillé

dans le user guide
Utilisation d’un solveur de suivi d’interface (VoF)
Utilisation de l’utilitaire setFields pour

initialiser des champs.
$ run ¶
$ cp –r $FOAM_TUTORIALS/multiphase/interFoam/laminar/damBreak Exo4 ¶
$ cd Exo4 ¶
$ cp ../Exo3/constant/polyMesh/blockMeshDict constant/polyMesh/.
atmosphere
3 2
7 6
0 1
fixedWalls
y z
x

Exercice n°4 : Ascension d’une bulle (3a/5)
$ gedit 0/alpha1.org¶
alpha1 représente la distribution

gaz/liquide dans le domaine (alpha1=0
pour le gaz, alpha1=1 pour l’eau)
Cette distribution sera initialisée par la

suite avec l’outil setFields. A ce stade,
seules les conditions aux limites sont
nécessaires.
setFields écrasera 0/alpha1, c’est

pourquoi on en fait une sauvegarde
0/alpha1.org

Exercice n°4 : Ascension d’une bulle (3b/5)
$ gedit 0/p_rgh¶
On utilise ici une pression hydrostatique

Exercice n°4 : Ascension d’une bulle (3c/5)
$ gedit 0/U¶

Exercice n°4 : Ascension d’une bulle (3d/5)
$ gedit constant/transportProperties¶
Eau définit dans le domaine

par alpha1=1
Air, définit pour alpha1 = 0
Tension de surface

Exercice n°4 : Ascension d’une bulle (3e/5)
$ gedit constant/g ¶

Exercice n°4 : Ascension d’une bulle (3f/5)

Avant de lancer le calcul, il faut initialiser la distribution gaz/liquide. On utilise setFields
$ cp 0/alpha1.old/ 0/alpha1¶
$ paraFoam ¶
$ gedit system/setFieldsDict ¶
$ setFields ¶
$ paraFoam ¶
AVANT APRES

Lancement du calcul : $ interFoam ¶
Post-traitement avec ParaView : $ paraFoam¶
t=0s t = 0.04 s t = 0.07 s





Où trouvez le code source d’un programme ?
OpenFOAM peut-être vu comme une boîte à outils facilement programmable
1 solver = 1 programme
(par exemple l’équation de la chaleur se résout avec le solveur laplacianFoam)
Où trouvez les solvers dans OpenFOAM ?

$ cd $FOAM_APP/solvers/¶
$ ls
Les solveurs sont classés par type (basic, heat transfer, combustion, incompressible,
multiphase….)
Par exemple, on trouve laplacianFoam dans /basic

$ cd basic/laplacianFoam ¶
$ ls ¶
$ gedit laplacianFoam.C ¶

Derrière laplacianFoam : laplacianFoam.C
Appel des librairies

d’OpenFOAM
Création de la matrice
fvm:: termes implicites
fvc:: termes explicites
T et DT déclarés dans
createField.H

Derrière laplacianFoam : createFields.H
On déclare le champ T comme une instance de
l’objet volScalarField.
- Il s’agit d’un champ scalaire
- Il doit être lu au temps initial
-il est dimensionné (les dimensions sont définis

dans 0/T)
- Il est écrit dans chaque répertoire du pas de temps
(runTime.timeName())
- Il contient les conditions aux limites
On lit le fichier transportProperties dans le

répertoire /constant
On déclare ici la variable DT
Sa valeur et ses dimensions sont défnits dans

constant/transportProperties

Code source.
Le fichier .C est le fichier principal.
Liste des fichiers à compiler
Liens vers les librairies OpenFOAM utilisées dans

l’application
Exemple du solver icoFoam

$ cd $FOAM_APP/solvers/incompressible/icoFoam ¶
$ ls ¶
$ gedit icoFoam.C ¶

Exercice n°5 : Ajout d’une équation de transport
dans icoFoam (1/4)
Objectif : développer un solver qui résout le couplage Navier-

Stokes + équation de la chaleur
Comment faire ??
Ajouter l’équation de transport d’un champ de températures à un

solver Naviers-Stokes déjà existant
On choisit de modifier le solver Naviers-Stokes incompressible

icoFoam

dans icoFoam (2/4)
On créé son espace « application » dans le répertoire personnel
$ cd $WM_PROJECT_USER_DIR ¶
$ mkdir -p applications/solvers/incompressible ¶
$ cd applications/solvers/incompressible ¶
Copie du solver icoFoam que l’on modifera ensuite

$ cp –r $FOAM_APP/solvers/incompressible/icoFoam myIcoFoam ¶
$ cd myIcoFoam ¶
$ mv icoFoam.C myIcoFoam.C¶
$ gedit Make/files ¶
Fichier principal de l’appication
L’application « myIcoFoam » sera

compilée dans un dossier utilisateur
Liens vers les librairies OpenFOAM
Compilation de myIcoFoam
$ wclean ¶
$ wmake ¶

dans icoFoam (3/4) $ gedit createFields ¶
Déclaration du scalaire DT. Il sera lu

dans le fichier
« constant/transportProperties »
Déclaration du champ scalaire T.

-Ce champ apparaitra dans chaque
répertoire de pas de temps
-On précise qu’il doit être lu à
l’initialisation du calcul

dans icoFoam (3/4) $ gedit myIcoFoam.C ¶
- Naviers-Stokes calculé par l’algorithme
PISO de icoFoam
- Le champ « phi » représente le flux

surfacique de vitesse
A jout de l’équation de la chaleur après la

résolution du couplage pression vitesse.
-L’équation est codée dans la matrice TEqn
-On aurait pu aussi directement écrire

solve
(
fvm::ddt(T)
+ fvm::div(phi,T)
Compilation de myIcoFoam - fvm::laplacian(DT,T)
);
$ wmake ¶

Exercice n°6 : température dans cavité entrainée (1/3)
T=493 K Ux=1m/s Objectif : simuler un transport de chaleur

dans le cas de la cavité entrainée
movingWall
Adapter l’exercice n°2 au transport de

T=293 K
T=293 K
température
T=293 K Résolution de Navier-Stokes incompressible

en régime laminaire et de l’équation de la
fixedWalls
fixedWalls
chaleur (notre solver myIcoFoam)
y
fixedWalls T=293 K
x
$ run ¶
$ cp –r Exo2 Exo6¶
$ cd Exo6 ¶
$ rm –r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9* ¶
$ cp 0/p 0/T ¶
$ gedit 0/T ¶

Exercice n°6: température dans cavité entrainée(2a/3)
$ gedit 0/T¶
Conditions initiales et conditions aux

limites pour le champ T

Exercice n°6: température dans cavité entrainée(2b/3)
$ gedit constant/transportProperties¶
Valeur du coefficient de diffusion

pour la température

Exercice n°6: température dans cavité entrainée(2c/3)
$ gedit system/fvSolution¶
Paramètres du solveur linéaire pour T

Exercice n°6: température dans cavité entrainée(2d/3)
$ gedit system/fvSchemes¶
Schéma de discrétisation pour

l’équation en température

Exercice n°6: température dans cavité entrainée(2e/3)
$ gedit system/controlDict¶
Le temps est plus long pour

atteindre le régime établie

Exercice n°6: température dans cavité entrainée (3/3)
$ myIcoFoam ¶
$ paraFoam ¶





Exercice n°7 : Créer un solveur “Darcy” (1/6)
Objectif : développer un solveur qui résout l’écoulement dans un milieu
poreux où la vitesse est évaluée par une loi de Darcy.
(1)
(2)
Comment résoudre un tel système ? On obtient une équation différentielle

sur la pression en injectant (2) dans (1) :
On va créer notre solveur en se basant sur le solveur existant laplacianFoam

$ cd $WM_PROJECT_USER_DIR/applications/solvers/ ¶
$ cp –r $FOAM_APP/solvers/basic/laplacianFoam darcyFoam ¶
$ cd darcyFoam ¶
$ mv laplacianFoam.C darcyFoam.C ¶

$ gedit createFields.H ¶
Déclaration du champ scalaire p.

-Ce champ apparaitra dans chaque répertoire de
pas de temps
-On précise qu’il doit être lu à l’initialisation du calcul
Déclaration du champ vitesse U.

-Ce champ apparaitra dans chaque répertoire de
pas de temps,
- Il ne sera pas lu à l’initialisation du calcul (même
si il est présent dans le répertoire 0),
- Pour satisfaire tous les constructeurs de l’objet
volVectorField, on précise via un argument
supplémentaire la dimension et une valeur initiale
de U.
Déclaration de la viscosité du fluide mu et de la

perméabilité k du milieu poreux. Ils seront lus dans
le fichier « constant/transportProperties »
$ gedit darcyFoam.C ¶
Le champ de pression p est évalué par

une équation de diffusion
Le vecteur vitesse U est déduit du

champ de pression par la loi de Darcy
$ rm write.H ¶
$ wclean ¶
$ wmake ¶
On supprime les fichiers inutiles

et on compile le programme
darcyFoam

On prépare le « case » en s’appuyant sur le tutorial
laplacianFoam/flange, dont le paramétrage se rapproche le plus de
Astuce pour définir les
coordonnées des notre exemple
points $ run ¶
$ mkdir darcyFoam ¶
$ cd darcyFoam ¶
$ cp -r $FOAM_TUTORIALS/basic/laplacianFoam/flange Exo7 ¶
$ cd Exo7 ¶
$ rm Allrun Allclean flange.ans ¶
Nous allons simuler l’écoulement dans un milieu poreux 1D :
Définition du maillage 3
2
(Maillage homogène, 1 seule inlet 7 6 outlet
maille dans les directions y et 0
1
z car le calcul est 1D)
y z 4 5
x
Pour gagner du temps, on récupère un blockMeshDict déjà existant,

que l’on va modifier
$ cp $FOAM_TUTORIALS/incompressible/icoFoam/cavity/constant/
polyMesh/blockMeshDict constant/polyMesh/. ¶
Les faces orthogonales $ gedit constant/polyMesh/blockMeshDict ¶
aux axes Oy et Oz sont
« vides » pour préciser
que le calcul est 1D
On créé ensuite le maillage à l’aide de blockMesh

$ blockMesh ¶
Exercice n°7 : Créer un solveur “Darcy” (5a/6)
$ mv 0/T 0/p ¶
$ gedit 0/p ¶
On impose un différentiel de
pression entre l’entée et la sortie du
domaine

Exercice n°7 : Créer un solveur “Darcy” (5b/6)

Exercice n°7 : Créer un solveur “Darcy” (5c/6)
darcyFoam est un solveur stationnaire, un

seul pas de temps est donc suffisant.

Exercice n°7 : Créer un solveur “Darcy” (5d/6)

Exercice n°7 : Créer un solveur “Darcy” (5e/6)
$ gedit system/fvSolution ¶

On lance la simulation : $ darcyFoam ¶
On va tracer les résultats à l’aide de l’outil d’échantillonnage sample, livré avec OpenFOAM, et du
programme Gnuplot. Comme blockMesh, sample requiert un fichier d’entrée, sampleDict, placé
quant-à-lui dans le répertoire /system :
$ cp $FOAM_UTILITIES/postProcessing/sampling/sample/sampleDict system/. ¶
$ gedit system/sampleDict ¶
On exécute ensuite l’échantillonnage :

$ sample ¶
Et on trace le champ de pression avec gnuplot :

$ gnuplot ¶
gnuplot> set xlabel "distance (m)" ¶
gnuplot> set ylabel "Pressure (kg/m/s)" ¶
gnuplot> plot "sets/1/lineX1_p.xy" using 1:2 with lines lw 4 title "p“ ¶

Exercice n°8 : Température dans un milieu poreux (1/7)
Objectif n°1 : développer un solveur qui résout le transport d’un champ

scalaire dans un milieu poreux où la vitesse est évaluée par une loi de
Darcy.
(1)
(2)
(3)
Objectif n°2 : Tracer les résultats en fonction du temps en plaçant des

sondes.
Objectif n°3 : Changer les schémas de discrétisation
On va créer notre solveur en se basant sur le solveur précédent darcyFoam

$ $ cp –r darcyFoam darcyTemperatureFoam ¶
$ cd darcyTemperatureFoam ¶
$ mv darcyFoam.C darcyTemperatureFoam.C ¶

Déclaration du flux de vitesse phi.

- Il s’agit d’un champ surfacique (vecteur U projeté
sur les surfaces du maillage)

- nécessaire pour utiliser l’opérateur divergence
(fvm::div(phi,T) )
- Peut également être déclaré avec
#include ‘’createPhi.H’’
Déclaration du champ de température T.
En plus de la viscosité du fluide mu et de la

perméabilité k du milieu poreux, on déclare la
diffisivité thermique DT et la porisité eps. Ils seront
lus dans le fichier « constant/transportProperties »

$ gedit darcyTemperatureFoam.C ¶
Le flux surfacique phi est actualisé à

partir de la nouvelle valeur du champ
de vitesse U.
Résolution de l’équation
d’advection/diffusion de la température
$ wclean ¶
$ wmake ¶
on compile le programme
darcyTemperatureFoam

On cherche à évaluer la température dans un milieu poreux 1D

Milieu poreux de perméabilité k

P1 et de porosité eps
P0
Flux libre en sortie

Tin
On va se baser sur l’exercice précédent pour paramétrer le calcul

$ run ¶
$ mkdir darcyTemperatureFoam ¶
$ cp –r ../darcyFoam/Exo7 Exo8 ¶
$ cd Exo8 ¶
$ rm –r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9* sets ¶
$ cp 0/p 0/T ¶
$ gedit 0/T ¶
Exercice n°8 : Température dans un milieu poreux (5a/7)
$ gedit 0/T¶

Exercice n°8 : Température dans un milieu poreux (5b/7)

Exercice n°8 : Température dans un milieu poreux (5c/7)

Exercice n°8 : Température dans un milieu poreux (5d/7)
$ gedit system/fvSolution ¶

Exercice n°8 : Température dans un milieu poreux (5e/7)
Les sondes sont des fonctions qui sont exécutées

au cours du calcul.
Elles permettent de tracer la valeur d’un champ

pour une cellule donnée (la sonde) au cours du
temps.
On peut préciser autant de sondes qu’on le désire.

On lance la simulation : $ darcyTemperatureFoam ¶
On va tracer les résultats des sondes à l’aide du script gnuplot suivant $ gedit plot_probes ¶
$ gnuplot –persist plot_probes ¶

On remarque des oscillations dans la simulation précédente. Elles sont dues à une mauvaise stabilité
des schémas numériques de convection utilisés. On peut utiliser un schéma amont ou limiteur de pente
en précisant, dans system/fvSchemes Gauss upwind phi ou Gauss vanLeer au lieu de Gauss linear.
Le schéma amont est plus stable, mais plus diffusif. Les schémas du type limiteur de pente semblent
plus adaptés.

Exercice n°9 : Personnaliser des conditions aux limites (1/4)
Objectif : Créer des conditions aux limites personnalisées

De base, OpenFOAM, gère un certain nombre de conditions à la limite. Elles sont situées dans le
répertoire suivant :
$ cd $FOAM_SRC/finiteVolume/fields/fvPatchFields ¶
$ ls ¶
Toutes ces conditions sont dérivées des conditions de base fixedValue et fixedGradient.
$ ls derived ¶
Pour définir une condition à la limite qui dépend du temps ou des autres champs, il existe
plusieurs possibilités :
• Programmation en dure dans le code
• Programmation de condition aux limites personnalisées
• Utilisation de l’utilitaire swak4Foam (http://openfoamwiki.net/index.php/Contrib/swak4Foam)
Exercice n°9 : Personnaliser des conditions aux limites (2/4)
Dans les exercices précédents (6 et 7), nous évaluons l’écoulement dans un milieu poreux à partir
de la résolution d’une équation différentielle sur la pression. Les conditions aux limites sont donc
précisées sur la pression. Dans certain cas cependant, il est plus commode de définir une vitesse
en entrée du domaine plutôt qu’une pression. Il faut donc traduire cette condition d’entrée en vitesse
en une condition d’entrée en pression via la relation :
Nous allons créer une condition à la limite personnalisée, inspirée de la condition buoyantPressure,
( ) elle-même dérivée d’un fixedGradient.
$ cd $WM_PROJECT_USER_DIR/ ¶
$ mkdir boundaryConditions/ ¶
$ cd boundaryConditions/ ¶
$ $ cp –r $FOAM_SRC/finiteVolume/fields/fvPatchFields/derived/buoyantPressure darcyGradPressure¶
$ cd darcyGradPressure ¶
$ rename 's/buoyantPressure/darcyGradPressure/g' *.* ¶
$ sed -i 's/buoyantPressure/darcyGradPressure/g' *.* ¶
$ mkdir Make ¶
On remplace la chaine de caractère « buoyantPressure » par « darcyGradPressure » à
l’intérieur de tous les fichiers du répertoire
$ gedit Make/files ¶ $ gedit Make/options ¶

Exercice n°9 : Personnaliser des conditions aux limites (3a/4)
$ gedit darcyGradPressureFvPatchScalarField.H ¶
Cette condition à la limite dérive de la

condition de base « fixedGradient »
On précise que le gradient de p sera

calculé à partir de U
Nom de la condition à la limite qu’il

faudra préciser dans les fichiers
0/p
Déclaration des constructeurs

Exercice n°9 : Personnaliser des conditions aux limites (3b/4)
Suite de la déclaration des

constructeurs et des constructeurs
de copie
Déclaration de la fonction updateCoeffs().

C’est à travers cette fonction que
l’expression de la condition à la limite est
définie
Déclaration de la fonction write()

qui écrit les valeurs aux limites
dans les fichiers timeDirectory/p

Exercice n°9 : Personnaliser des conditions aux limites (4a/4)
$ gedit darcyGradPressureFvPatchScalarField.C ¶
Définition des constructeurs et des constructeurs de copie

Exercice n°9 : Personnaliser des conditions aux limites (4b/4)
On récupère la valeur du champ
de vitesse U au niveau de la
condition à la limite
On récupère les valeurs

de la viscosité du fluide et
de la perméabilité du
milieu poreux dans le
fichier transportProperties
On évalue ici le gradient de pression à la limite

selon la formule :
mu.value() permet d’accéder à la valeur de

l’objet mu déclarer comme dimensionedScalar
patch().nf() renvoie le vecteur normal au patch
$ wclean ¶
$ wmake libso ¶
on compile la librairie ldarcyGradPressure.so

qui est maintenant valable pour tous les
solveurs
Exercice n°10 : Modèle à 2 températures (1/6)
Objectif n°1 : Résoudre un transfert de chaleur dans un milieu poreux
par un modèle à 2 équations
(1)
(2)
(3)
(4)
Objectif n°2 : Utiliser des conditions à la limite personnalisées
On va créer notre solveur en se basant sur le solveur darcyTemperatureFoam

$ $ cp –r darcyTemperatureFoam darcyTwoTemperaturesFoam ¶
$ cd darcyTwoTemperaturesFoam ¶
$ mv darcyTemperatureFoam.C darcyTwoTemperaturesFoam.C ¶

Le champ U est
maintenant initialisé à
partir de 0/U, ce qui
nous permet de définir

des conditions d’entrée
pour U
phi est créé en

appelant
createPhi.H
Déclaration des
champs de
température pour le
solide et pour le
fluide
Les constantes du modèles seront

lues dans le fichier
constant/transportProperties

$ gedit darcyTwoTemperaturesFoam.C ¶
Résolution de la température dans

le fluide. Une partie du terme
d’échange est traitée en implicite,

l’autre en explicite.
Résolution de la température
dans la matrice poreuse.
$ wclean ¶
$ wmake ¶

On cherche à évaluer le transfert de chaleur dans un milieu poreux 1D via un modèle à
deux températures
Dans cet exemple, un milieu poreux initialement à 573K est refroidit par l’injection d’un
fluide à 273K
Milieu poreux de perméabilité k

Vitesse Uin imposée et de porosité eps
en entrée P0
Température du fluide Flux de chaleur (fluide et

Tfin imposée en entrée solide) libre en sortie
On va se baser sur l’exercice précédent pour paramétrer le calcul
$ run ¶
$ mkdir darcytwoTemperaturesFoam ¶
$ cp –r ../darcyTemperatureFoam/Exo8 Exo10 ¶
$ cd Exo10 ¶
$ rm –r 0.* 1* 2* 3* 4* 5* 6* 7* 8* 9* sets probes ¶
$ mv 0/T 0/Tf ¶
$ cp 0/Tf 0/Ts
$ gedit 0/Tf ¶

Exercice n°10 : Modèle à 2 températures (5a/6)
$ gedit 0/U ¶
On impose une vitesse du fluide à

l’entrée du milieu. Cette vitesse va
permettre d’évaluer le gradient de
pression à l’entrée.

Exercice n°10 : Modèle à 2 températures (5b/6)
$ gedit 0/p ¶
On utilise ici la condition à la limite

darcyGradPressure définie dans l’exercice
précédent. Le gradient de pression à la limite est
évalué via :
On doit préciser dans le fichier system/controlDict

que l’on utilise la librairie ldarcyGradPressure.so

Exercice n°10 : Modèle à 2 températures (5c/6)
$ gedit 0/Ts ¶

Exercice n°10 : Modèle à 2 températures (5d/6)
$ gedit 0/Tf ¶

Exercice n°10 : Modèle à 2 températures (5e/6)

Exercice n°10 : Modèle à 2 températures (5f/6)
On précise ici que l’on va utiliser la librairie

ldarcyGradPressure.so qui nous permettra
d’utiliser la condition à la limite personnalisée
darcyGradPressure

Exercice n°10 : Modèle à 2 températures (5g/6)
$ gedit system/fvSolution ¶ $ gedit system/fvSchemes ¶

On lance la simulation : $ darcyTwoTemperaturesFoam ¶
On post-traite ensuite les résultats (ici on a tracé les valeurs de Ts et Tf en fonction du temps pour
les 3 sondes)


zzOPENFOAM PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

zzOPENFOAM PDF

Transféré par

Droits d'auteur :

Formats disponibles

Initiation à la CFD open-source avec le

• Connaitre les possibilités du code OpenFOAM®

• Savoir trouver de l’aide

• Savoir lancer et post-traiter un calcul à partir des tutoriaux existants

• Lancer un calcul en adaptant les tutoriaux à son propre cas

• Savoir décrypter un solveur pour identifier le plus adapté à sa situation

• Créer son propre solveur en modifiant un solveur existant

• Oser se lancer dans l’aventure OpenFOAM® …

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 2

Premières simulations avec OpenFOAM®

Programmer des équations avec OpenFOAM®

Transfert en milieu poreux avec OpenFOAM®

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 3

Premières simulations avec OpenFOAM®

Programmer des équations avec OpenFOAM®

Transfert en milieu poreux avec OpenFOAM®

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 4

= Open Field Operation and Manipulation

1989 : Début du développement à l’Imperial College London

- Mailleur (blockMesh, snappyHexMesh…)

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 6

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 7

Le champ considéré peut-être scalaire, vectoriel ou tensoriel

2 guides officiels par OpenCFD (« user guide » et « programmer guide » )

Un tutorial par solver. Il a souvent valeur de cas-test (Validation non-disponible

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 9

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 10

• Gratuit (pas de limitations dues aux licences), • Temps de prise en main,

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 11

Premières simulations avec OpenFOAM®

Programmer des équations avec OpenFOAM®

Transfert en milieu poreux avec OpenFOAM®

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 12

Paramétrage du calcul (choix des solvers, des schémas

Toutes valeurs constantes pendant le calcul (Propriétés

Contient les informations relatives au maillage

Un répertoire par pas de temps. Chaque répertoire

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 13

Tini = 273K Exemple issu des tutoriaux livrés

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 14

Conditions initiales et conditions aux limites

Paramètres du calcul (pas de temps, sorties

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 15

Température initiale uniforme (T=273K)

Condition à aux limites à t=0s

Valeur fixe (T=273K)

Valeur fixe (T=573K)

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 16

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 17

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 18

Lancement de la simulation Création d’un répertoire / pas de

Visualisation du résultat dans paraView

Création de la géométrie et du maillage

Post-traitement avec ParaView

que des géométrie 3D

Définition du maillage (Maillage y z

6 – Edit>view Setting>use Parallel Projection

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 22

On est donc bien en régime

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 23

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 24

Attention aux unités, ici,

Cyprien Soulaine - Institut de Mécanique des Fluides de Toulouse 25