Université Paris-Saclay M2 DFE – 2020-2021

Logiciels de simulation CFD

Tutoriel OpenFOAM
Cavité entraînée

1. DÉFINITION DU PROBLÈME PHYSIQUE

On cherche à simuler l’écoulement au sein d’une cavité fermée bidimensionnelle dont la paroi
supérieure est mobile. La géométrie considérée est un domaine carré de 1m par 1m. On suppose
que les équations gouvernant cet écoulement sont les équations de Navier-Stokes pour un
écoulement incompressible.
U

Domaine de calcul de la cavité entraînée

Cet écoulement est caractérisé par la hauteur de la cavité (H=1mm), la vitesse de déplacement de la
paroi supérieure (U=1m/s) et la viscosité cinématique du fluide (n). En imposant la valeur du nombre
de Reynolds (Re= UD / n) caractérisant l’écoulement (ici Re=100), on en déduit la valeur de la
viscosité.
Cet écoulement ne possède pas de solution analytique mais des résultats de référence calculés avec
des méthodes précises et très bien résolues sont disponibles. Avec le logiciel OpenFOAM, on va
donc essayer de simuler cet écoulement et les comparer aux références.

2. PRÉSENTATION D’OPENFOAM
OpenFOAM est composé d’un ensemble d’exécutables. Nous allons en utiliser quelques-un selon la
chaîne de calcul suivante :

paraFoam
blockMesh (visualisation)
icoFoam
(géométrie & maillage) (solveur NS)

sampling

Chaîne d’un calcul OpenFOAM

Il n’existe pas d’interface graphique (GUI) d’OpenFOAM : tous les exécutables sont donc appelés en
ligne de commande. Il faut donc démarrer une fenêtre de terminal et se placer dans le répertoire
dans lequel on souhaitera calculer cet écoulement.
Copier le cas de la cavité d’après le tutorial fourni :
$ cp -r $FOAM_TUTORIALS/incompressible/icoFoam/cavity/cavity .

1
$ ls *

• STRUCTURE DU RÉPERTOIRE DE TRAVAIL

Tous les cas OpenFOAM sont structurés de cette façon :
• Le répertoire system contient le contrôle de l’exécution du
solveur et du mailleur.
• Le répertoire constant contient les propriétés physiques,
des modèles de turbulence, des modèles physiques
avancés, etc.
• Le sous-répertoire constant/polymesh contient les
informations sur les maillages polyédriques.
• Le répertoire 0 contient les conditions initiales et les
conditions aux limites.

3. PREMIÈRE EXÉCUTION
Nous allons suivre la chaîne de calcul ci-dessus en exécutant les différents outils et en commentant
leur usage. Le détail sera donné dans la section suivante.
Premièrement, on crée le maillage directement à partir d’une géométrie simple :
$ blockMesh
Ce maillage est créé dans le répertoire constant/polymesh qui n’existait pas auparavant.
On peut vérifier les principales caractéristiques de ce maillage avec l’utilitaire suivant :
$ checkMesh
ou encore en le visualisant avec :
$ paraFoam &
Sur l’interface, on clique d’abord sur le bouton
Apply, puis dans la bandeau du haut, à la place
de Surface on sélectionne Surface With Edge. On
referme ensuite paraFoam.
Puis on simule ce problème avec le solveur
icoFoam :
$ icoFoam | tee log.icoFoam
L’exécutable tourne en tâche de fond et les sorties
(avec les résidus, les pas de temps, ...) sont
redirigées dans le fichier log.icoFoam.
Le solveur écrit aussi la solution à certains
instants dans les répertoires nouvellement créés :
0.1, 0.2… :
$ ls *
Finalement on ouvre à nouveau paraFoam (il a créé entre-temps un nouveau fichier cavity.foam
contenant les nouveaux fichiers).
$ paraFoam &
On peut alors se placer à dernière sauvegarde grâce à :
et aussi changer la variable affichée (pression ou vitesse) :

2
4. EN DÉTAIL
Nous allons maintenant reprendre les étapes précédentes, en les détaillant, pour pouvoir ensuite
modifier cette configuration d’écoulement.
Chaque fichier dans le répertoire de travail a
un entête en commentaires (lignes 1 à 7) et
une description obligatoire (lignes 8 à 15).
Le mot-clé class (ligne 12) est important
pour renseigner le type de fichier utilisé : par
défaut un dictionnaire (on verra plus loin
d’autres exemples).

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

• STRATÉGIE
Ces deux opérations ne sont pas strictement séparées dans OpenFOAM. L’utilitaire blockMesh
permet de concevoir des géométries élémentaires ou pouvant être décrites analytiquement qui sont
ensuite maillées de façon structurée. Pour la création de géométrie plus complexes, il est nécessaire
d’avoir recours à un outil de CAO externe et d’importer ensuite la géométrie.
Remarque : OpenFOAM est complètement dimensionnel. Il est donc important de bien définir les
dimensions pour chaque champ de dictionnaire et les propriétés physiques (cf plus loin pour les
conditions initiales et aux limites).

• DÉFINITION DU DOMAINE
Le dictionnaire blockMeshDict définit d’abord un
facteur d’échelle (ligne 17) : ici les coordonnées 3 2
seront donc données en décimètres. 7 6

On définit ensuite, lignes 21 à 28 une liste de

coordonnées de points de la géométrie. Ici 8
points sont nécessaires pour décrire la cavité car
OpenFOAM utilise toujours des maillages 3D, y

même si la simulation est 2D. x

z 0 1
La numérotation des points commence à 0
(provient du C++). 4 5

Les quatre premiers points fixent le repère

orthogonal .
Ensuite, sur les lignes 31 à 34, on associe ces points à un hexaèdre, pour définir un bloc structuré.
• DÉFINITION DU MAILLAGE
Sur la même ligne 33 où on définit l’hexaèdre, on précise aussi le maillage :
• Le premier triplet (20 20 1) donne le nombre de cellules par direction
• L’instruction suivant permet de spécifier le ratio d’expansion : ici le triplet (1 1 1) signifie
que le ratio de taille d’une cellule à l’autre est unitaire. Le maillage est donc uniforme.

3
 • DÉFINITION DES FRONTIÈRES
Dans ce fichier blockMeshDict de création de géométrie et de maillage, on
définit aussi les frontières. On leur assigne un type de condition à la limite dont
on précisera les autres caractéristiques plus loin.
Chaque frontière (patch) possède :
• un nom libre : movingWall
• un type défini par un mot-clé : wall, empty, …
• et un ensemble de faces (composées de points)
Dans la configuration de la cavité, les faces sud, est et ouest sont toutes de
type wall et regroupées dans le patch fixedWalls. L’ensemble faces comprend
donc la liste des points décrivant ces trois faces.
Attention : l’ordre des numéros de points est dans le sens horaire en regardant 3 2

la face depuis l’intérieur du bloc ! L’utilitaire checkMesh n’est pas capable de 7 6

détecter s’il existe une incohérence...

Le type empty pour les faces avant et arrière de la cavité permettent de y
signaler à OpenFOAM que c’est un cas 2D. x
z 0 1
4 5

blockMesh génère ensuite un ensemble de fichiers

qui vont permettre de décrire tout le maillage, avec la
position de chaque nœud du maillage (dans le fichier
points), la composition des nœuds de chaque face de
cellule (dans le fichier faces) et les relations de
connectivités (dans les fichiers neighbour et owner).
Dans le fichier boundary sont décrites les conditions
aux limites.
Ces patches sont en lien avec ceux qui ont été définis
dans le dictionnaire blockMeshDict :
• contiennent un nom
• définissent un base type
• référencent des faces (à ne pas modifier!!)
• inGroups est optionnel et sert au post-
traitement

Une fois définies les faces du maillages correspondant aux CL, avec leur base type, il faut définir les
valeurs numériques associées aux types de ces CL, avec leur numerical type. Ceci se fait dans les
fichiers de champ (dans le répertoire 0 : 0/U, 0/p, etc) que nous aborderons plus tard. Il est important
de souligner que ces deux types, base et numerical, soient consistants :
• ils doivent être identiques pour certains types :
constant/polyMesh/boundary 0/U, 0/p
symmetry symmetry
symmetryPlane symmetryPlane
empty empty
wedge wedge
cyclic cyclic
processor processor
• Pour le base type nommé patch, le numerical type peut être n’importe lequel des CL
4
 numérique d’OpenFOAM (Dirichlet, Neumann, etc) :
constant/polyMesh/boundary 0/U, 0/p
fixedValue
zeroGradient
inletOutlet
patch
slip
totalPressure
... (cf doc)
• le base type nommé wall est particulier : il n’est contenu dans base type patch car des options
de modélisation spécialisée peuvent s’appliquer sur les murs (cf turbulence et loi de paroi) :
constant/polyMesh/boundary 0/U 0/p
type fixedValue;
wall zeroGradient
value uniform (U V W);

4.2 Paramètres du solveur

Le solveur est contrôlé par un ensemble de paramètres que l’on trouve dans différents fichiers au
sein du répertoire system.
• SYSTEM/CONTROLDICT
Ce fichier contient les paramètres généraux sur la façon de faire tourner le
calcul. La plupart des entrées sont explicites.
• Ce cas est construit pour l’application icoFoam. Il ne
fonctionnera pas s’il est appelé avec un autre solveur depuis la
ligne de commande.
• Le cas part de l’instant 0 (startFrom). Si la solution initiale est
définie dans un autre répertoire, il faut modifier la ligne 22.
• Le calcul va tourner jusqu’à l’instant 0.5 (ligne 26), avec un pas
de temps de 0.005 (ligne 28) : il y aura donc 100 itérations
temporelles.
• L’écriture de la solution se fait tous les 20 pas de temps (ligne
30 & 32) et sont toutes conservées (ligne 34 – si l’on ne veut
que les 2 dernières, on change cette valeur à 2).
• Avec le paramètre de la ligne 46, on peut modifier tout ces
paramètres à la volée pendant l’exécution de la simulation (à
faire avec précaution).

5
 • SYSTEM/FVSCHEMES

Ce fichier contient les paramètres pour la discrétisation des

différents termes dans les équations.
• Pour le schéma temporel implicite, le schéma utilisé
est ici Euler.
• Pour la discrétisation des termes convectifs
(divSchemes), l’interpolation est linéaire : le schéma
est donc de type différences-centrées, de second
ordre (mais peut être oscillant).
• La ligne 31 signifie que le schéma doit être spécifié
de façon explicite.
La méthode toto permet de constater qu’il y a 8 schémas
disponibles pour la discrétisation temporelle et plus de 60 pour la
discrétisation spatiale !

• SYSTEM/FVSOLUTION

Ce fichier contient des paramètres sur la résolution de chaque

système d’équations linéaires et le couplage vitesse-pression.
• L’équation de Poisson sur la pression est ici résolue avec
le solveur linéaire PCG et préconditionné avec DIC.
• La solution est convergée quand le résidu a atteint le seuil
tolerance ou s’il a été réduit de relTol a chaque pas de
temps (si relTol est égal à 0, cette fonctionnalité est
désactivée).
• L’entrée pFinal se réfère à la correction de pression finale
du solveur PISO. La variable $p mentionne qu’on utilise
les paramètres du solveur pour p (PCG+DIC) sauf que
relTol est maintenant désactivé. Pour la dernière itération,
un effort de calcul plus important est donc nécessaire pour
réduire sous le seuil tolerance (=10-6) le résidu associé à
pFinal.
• Pour résoudre le système linéaire associé à U, le solveur
linéaire est différent. La tolérance absolue est plus faible
que pour la pression car le solveur pour U est moins
coûteux.
• Enfin un sous-dictionnaire est associé à la méthode de couplage vitesse-pression PISO :
◦ nCorrectors est le nombre de corrections PISO. Dans le fichier de sortie, on voit que la
résolution de la pression et donc le couplage vitesse-pression est effectué deux fois.
◦ nNonOrthogonalCorrectors ajoute des corrections pour les maillages non
orthogonaux.
◦ Si une CL n’impose pas une valeur pour la pression, celle-ci est prise égale à
pRefValue dans la cellule numérotée pRefCell.

6
4.3 Conditions aux limites et initiales
Les CL ont été évoquées lors de la création du maillage avec le dictionnaire blockMeshDict. Les
valeurs numériques associées à ces CL ainsi que les champs de condition initiale sont définis dans
les fichiers du répertoire 0.

Dimensions dans OpenFOAM (système métrique) :

Position Grandeur Unité Symbole
1 Masse Kilogramme kg
2 Longueur Mètre m
3 Temps Seconde s
4 Température Kelvin K
5 Quantité de matière Mole mol
6 Courant électrique Ampère A
7 Intensité lumineuse Candela cd

[ 1(kg) 2(m) 3(s) 4(K) 5(mol) 6(A) 7(cd) ]

• FICHIER 0/U
◦ Sur la ligne 17, on peut noter la dimension du champ de
vitesse dans le système métrique : en m/s
◦ Le mot clé internalField permet de préciser la condition
initiale à l’intérieur du domaine. Il s’agit ici d’un champ
vectoriel (volVectorField ligne 12) uniforme dont les 3
composantes sont nulles.
◦ Dans la structure boundaryField, on retrouve les mêmes
noms de patch que dans blockMeshDict (movingWall,
fixedWalls et frontAndBack) mais on précise ici leur
numerical type avec les valeurs numériques associées. Par
exemple, pour le mur mobile du haut, on précise les trois
composantes du vecteur vitesse, uniforme sur la paroi
haute.
◦ Étant dans un cas 2D, on précise pour les parois avant et arrière qu’aucune solution n’est
requise dans cette direction. Le patch est de type empty.

• FICHIER 0/P
◦ Le champ est ici scalaire, cf ligne 12 : volScalarField.
◦ La dimension est égale à m2/s2 (cf encadré ci-après)
◦ Les CL sont définies avec des numerical type appropriés.

7
Considération importante sur le champ de pression.
Tous les solveurs incompressibles implémentés dans OpenFOAM (icoFoam, simpleFoam, pisoFoam
et pimpleFoam) utilisent une pression modifiée définie par :
p m2
P= ρ dont l’unité est 2
(dans le jargon OpenFOAM : [ 0 2 -2 0 0 0 0 ] )
s
Pour la visualisation ou le post-traitement des résultats, il ne faut pas oublier de multiplier cette
pression modifiée par la densité pour retomber sur les bonnes unités de la pression :
kg
2
(dans le jargon OpenFOAM : [ 1 -1 -2 0 0 0 0 ] )
m⋅s

• FICHIER CONSTANT/TRANSPORTPROPERTIES
Son contenu est permet de préciser les propriétés du fluide, dans
les dimensions du système métrique. Ici on a donc :
m2
ν=0.01
s
L’écoulement étant incompressible, c’est la seule propriété physique qu’il est nécessaire de définir.
Pour d’autres types d’écoulements, on pourra rajouter dans ce fichier d’autres propriétés, comme la
densité, la tension de surface, la constante de gravité, etc. Pour des écoulements compressibles, on
renseignera le dictionnaire thermophysicalProperties.

4.4 Exécution du calcul

Le lancement du solveur se fait avec la commande icoFoam :
$ icoFoam | tee log.icoFoam
dont on a ici agrémenté une redirection de la sortie vers le fichier log.icoFoam afin de garder une
trace de l’affichage.

Time = 0.5

Courant Number mean: 0.222158 max: 0.852134

smoothSolver: Solving for Ux, Initial residual = 2.3091e-07, Final residual = 2.3091e-07, No Iterations 0
smoothSolver: Solving for Uy, Initial residual = 5.0684e-07, Final residual = 5.0684e-07, No Iterations 0
DICPCG: Solving for p, Initial residual = 8.63844e-07, Final residual = 8.63844e-07, No Iterations 0
time step continuity errors : sum local = 8.8828e-09, global = 5.49744e-19, cumulative = 3.84189e-19
DICPCG: Solving for p, Initial residual = 9.59103e-07, Final residual = 9.59103e-07, No Iterations 0
time step continuity errors : sum local = 9.66354e-09, global = -1.28048e-19, cumulative = 2.56141e-19
ExecutionTime = 0.18 s ClockTime = 1 s

End

Les informations suivantes sont fournies :

• Initial/Final residual : correspond au résidu du système linéaire (Ux, Ux ou p) avant/après
résolution par le nom du solver mentionné en début de ligne (smoothSolver, DICPCG, …). Ce
résidu final doit être plus faible que la tolérance requise.
• La résolution de l’équation de pression apparaît deux fois car on a demandé deux corrections
PISO.
• time step continuity errors : estimation de la divergence du champ de vitesse qui doit être la
plus petite possible en incompressible ! ϵlocal =Δ t ⟨|∇⋅u|⟩ ϵ global =Δ t ⟨∇⋅u⟩
ϵ cumulative= ϵcumulative + ϵ global
• Le temps d’exécution depuis le début du calcul (ExecutionTime=CPU Time et ClockTime =

8
 Wall Clock Time : ces deux temps différent légèrement suivant la charge de l’ordinateur)
ui
• Le nombre de Courant est calculé comme CFL=Δ t ∑ . La plupart des solveurs sont
i Δ xi
implicites, donc inconditionnellement stables (pas de CFLmax à ne pas dépasser). Cependant
il est raisonnable de garder le CFL modéré (proche de 1, en dessous de 5).
Pour suivre l’évolution des résidus au cours du calcul, il peut plus efficace de les visualiser.
OpenFOAM ne fournissant pas cette capacité nativement, on peut utiliser un script Python de la
collection PyFoam.
Puis l’utilisation fait appel au fichier log.icoFoam généré lors du premier calcul :
$ pyFoamPlotWatcher.py log.icoFoam
Une autre utilisation est possible où le script lance le solveur (icoFoam) :
$ pyFoamPlotRunner.py icoFoam
et simultanément fait l’écriture du fichier de sortie (nommé PyFoamRunner.icoFoam.logfile). Cela
peut être pratique pour surveiller un calcul long sans avoir à ouvrir un autre terminal dans le même
dossier.

4.5 Astuces
• ANALYSE D’ERREURS
Comment connaître les mots-clés autorisés pour chaque paramètre ? Utiliser la méthode toto !
• Remplacer la valeur du paramètre stopAt par toto à la
ligne 24 du fichier controlDict :
• Exécuter le solveur : $ icoFoam
• Analyser le message d’erreur : --> FOAM FATAL IO ERROR:
toto is not in enumeration:
◦ Repérer le fichier fautif et la ligne de l’erreur (ici 4
(
fichier ContolDict, ligne 24) endTime
nextWrite
noWriteNow
◦ Analyser l’origine de l’erreur writeNow
)
file: /cavity/system/controlDict.stopAt
◦ Utiliser une option possible proposée pour corriger at line 24.
l’erreur

Attention : cette méthode n’arrête pas forcément la simulation : le solveur peut renvoyer seulement
un message d’avertissement et continuer le calcul (par exemple, tester toto sur le paramètre
timeFormat ligne 42 de controlDict).

• AIDES
Une aide pour l’exécution est disponible pour chaque commande :
$ blockMesh -help
Une aide plus exhaustive est disponible sur https://cfd.direct/openfoam/user-guide (pour la version 7)
et https://openfoam.com/documentation/user-guide/ (pour la version 20.06)
La documentation développeur est la plus complète mais nécessite parfois de décoder les sources…
https://cpp.openfoam.org/v7/ ou https://openfoam.com/documentation/guides/latest/doc/ (pour la
version 20.06). Certaines informations utile pour la version 7 peuvent se trouver en lisant la
documentation de la version 20.06...

9
 • DICTIONNAIRES
La syntaxe des dictionnaires découle du C++ .
Les tabulations n’ont pas d’importance. Pas contre la casse est sensible !
// Commentaires
/*
Les commentaires se font avec // ou /* */ . Bloc de commentaires
*/
L’utilisation de macro permet de simplifier les manipulations :
vectorField (20 0 0); //Déclare la variable
• substitution internalField uniform $vectorField; //Utilise la variable

p // Déclare/crée le dictionnaire
• duplication {
solver PCG ;
preconditioner DIC ;
tolerance 1e-06 ;
relTol 0 ;
}

$p; //Pour créer une copie du dictionnaire

$p.solver; //Pour accéder à une variable dans le dictionnaire

X 10.0; //Déclare la variable

• calculs à la volée Y 3.0; //Déclare la variable
Z #calc “$X*$Y – 12.0”; //Calcul en ligne et sauve dans Z

• expressions régulières

“(left|right|top)Wall ” leftWall
{ {
type fixedValue; type fixedValue;
value uniform (0 0 0); value uniform (0 0 0);
} }
rightWall
2 formes {
type fixedValue;
équivalentes à value uniform (0 0 0);
“.*Wall ” }
{ topWall
type fixedValue; {
value uniform (0 0 0); type fixedValue;
} value uniform (0 0 0);
}

5. POST-TRAITEMENT
OpenFOAM dispose d’un outil, postProcess, permettant de post-traiter les données pendant le calcul
ou a posteriori une fois le calcul fait. Cette dernière méthode peut aussi s’effectuer avec paraFoam et
offre des possibilités différentes.
Les deux dernières méthodes (post-traitement a posteriori avec l’outil interne postProcess ou avec
paraFoam) dépendent fortement de la fréquence d’écriture des fichiers de sortie.

5.1 A posteriori
• AVEC POSTPROCESS
Pour utiliser l’outil postProcess, il faut lui préciser un dictionnaire particulier. On va utiliser un fichier
d’un tutoriel, en cherchant dans ceux fourni par openFOAM :
$ find $FOAM_TUTORIALS -iname sample
Cette commande doit renvoyer une liste de fichier sample. Choisir celui de la cavité et le copier dans
le répertoire system :

10
$ cp $FOAM_TUTORIALS/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/
sample system/sample
On va le modifier pour préciser qu’on veut extraire un profil
de vitesse sur la ligne à mi-hauteur de la cavité :
• le premier champ, ligne 19, permet de préciser que
l’on fait un échantillonnage sur un ensemble (sets).
L’autre possibilité est sur une surface.
• On renseigne ensuite le dictionnaire de sets lignes 28
à 34 :
◦ ligne 28, le nom de l’ensemble ;
◦ ligne 30, son type : ici une ligne échantillonnée
uniformément, selon la direction x ;
◦ coordonnées (x,y,z) du point de départ (ligne 32)
et d’arrivée (ligne 33) ;
◦ nombre de points d’échantillons (ligne 34).
• Enfin on précise quelle(s) variable(s) on souhaite
interpoler (ligne 38).

Une fois ce dictionnaire sample défini, on l’invoque par la commande :

$ postProcess -func sample
qui génère l’échantillonnage dans le répertoire postProcessing/sample, avec un sous-répertoire par
fichier de sortie (cf répertoires 0.1, 0.2, etc). Dans chacun d’eux, on trouve un fichier
HorizontalLine_U.xy dont on peut examiner le contenu avec :
$ gedit postProcessing/sample/0.5/HorizontalLine_U.xy
Pour chaque ligne, on retrouve pour chaque point d’interpolation : la coordonnée x, les trois
composantes de la vitesse. Pour visualiser le contenu de ce fichier, on va utiliser l’utilitaire Gnuplot :
$ gnuplot
Puis on rentre des commandes spécifiques à ce logiciel (cf
documentation/tutoriels sur internet) :
gnuplot> plot
'postProcessing/sample/0.5/HorizontalLine_U.xy'
u 1:3
qui permet de tracer la 3ème colonne (la composante V de la
vitesse) en fonction de la première (la coordonnée x).
Quitter Gnuplot avec les touches ctrl+D .

• AVEC PARAFOAM
On peut arriver au même résultat avec les outils de paraFoam. Une fois le
logiciel démarré, on choisit le filtre Plot Over Line via l’icône ci-contre ou par
le menu Filters > Data Analysis > Plot Over Line.
Dans les propriétés de ce filtre, il faut ensuite choisir :
• une ligne de type High Resolution Source Line
• les coordonnées x, y, z (en m) du point de départ (Point1) et de fin (Point2) de la ligne. On
peut utiliser le bouton X Axis pour avoir rapidement la ligne à mi-hauteur du domaine
• la résolution (ici celle du maillage) : 20
Une fois ce filtre validé, l’interpolation est exécutée et affichée. Pour sélectionner seulement la
vitesse verticale, dans les propriétés du filtre choisir pour Series Parameters la seule variable U_Y.

On obtient la représentation graphique suivante, similaire à celle affichée par Gnuplot :

11
Il existe une petite différence entre ceux deux représentations : laquelle ?

5.2 Pendant le calcul

Il peut parfois être plus avantageux d’avoir le post-traitement embarqué dans le calcul (lorsque les
sorties sont volumineuses, sur un gros maillage très fin, donc peu fréquemment écrites par exemple).
Cette fonctionnalité n’est pas contrôlée par un dictionnaire
de system/sample mais directement dans controlDict.

A la fin de ce fichier il faut ajouter le fonction ci-contre, qui

englobe quasiment les mêmes instructions que dans le
fichier sample vu plus haut.

La nouveauté propre à cette fonction est de pouvoir

contrôler l’intervalle temporel/itératif de l’échantillonnage
(sur les lignes 55 et 56). On peut donc faire une extraction
à des fréquences différentes de l’écriture de la solution sur
l’ensemble du maillage (cf lignes 30 et 32 de ce même
fichier controlDict).

Cette fonctionnalité étant embarquée dans le solveur, il

faut l’exécuter à nouveau. On peut nettoyer les résultats
du précédent calcul :
$ foamListTimes -rm
$ rm -r postProcessing
puis lancer le calcul
$ icoFoam | tee log.icoFoam
Les résultats sont maintenant dans postProcessing/LineVelocity puisque c’est le nom choisi pour ce
jeu d’interpolation. Seul le temps 0.5 est crée car l’échantillonnage ne s’est fait que tous les 100 pas
de temps. La structure du fichier .xy est la même que pour l’étape précédente et la visualisation se
fait aussi avec Gnuplot.

Ressources en ligne :
http://www.wolfdynamics.com/wiki/tut_cavity.pdf
http://web.student.chalmers.se/groups/ofw5/Basic_Training/icoFoamWalkThrough.pdf

12