Prise en main d'OpenFOAM

Présentation du logiciel

                                                                                                                                                                              

                                                                                                      Source : http://scc.kit.edu

OpenFOAM (Open Field Operation And Manipulation) est un solveur multi-physique (mécanique des solides, éléctromagnétisme, finance, ...etc) principalement orienté vers la mécanique des fluides, il a été conçu  en 1989 à l'Imperial College London, et il est ​dédié à la résolution des équations aux dérivées partielles par la méthode des volumes finis.

Il s'agit d'un code open-source développé en C++ (programmation orienté objet), conçu comme une boite à outils, il contient plus de 200 programmes (des pré-processeurs, des solveurs et des outils de post-traitement), il est réutilisable et modifiable à souhait, et l'utilisateur peut par ce biais programmer un nouveau solveur correspondant à son cas d'étude. Une autre caractéristique du logiciel est qu'il ne possède pas une interface graphique (comme Fluent, Code_Saturne,.. etc), toute la simulation numérique et le conditionnement du cas se fait dans des fichiers textes.

Ce code de calcul est une solution open source, et donc permet d'éviter les codes ce calcul payants avec un coût exorbitant des licences (Fluent, StarCCM+,...). Aussi, c'est un outil puissant, personnalisable, et offre à l'utilisateur une grande liberté de rentrer dans code, accéder à l'intérieur du code, comprendre tout le fonctionnement du code (contrairement à fluent par exemple où on sait jamais ce qui est à l'intérieur), et créer son propre solveur et ses propres modèles qui correspondent le mieux avec son cas d'étude. De même, ce logiciel est assez puissant en terme de performance, il permet de lancer des calcul sur un grand nombre de coeur sans surcoût.​

Ce logiciel présente un multitude de solveurs relatifs à différents domaines d'application, tels que les écoulements compressibles, les milieux multiphasiques, réactifs,...etc, nous en listons ceux qui sont les plus utilisés :

Nom de l'application (solveur) Type des problèmes à traiter
potentialFoam Initialiser un écoulement potentiel simple avant de commencer la résolution.
icoFoam Ecoulements laminaires, transitoires, incompressibles pour des fluides newtoniens.​​ ​
pisoFoam Ecoulements incompressibles en régime transitoire.
laplacianFoam Résolution de l'équation de Laplace (ex: diffusion thermique).
SimpleFoam Ecoulements stationnaires turbulents.
SonicFoam Ecoulements laminaires ou turbulents pour des gaz compressibles.
bubbleFoam Système de deux fluides incompressibles avec une phase dispersée.
reactingFoam Ecoulements réactifs en combustion.
buoyantBoussinesqSimpleFoam Solveur adapté aux calculs thermiques pour des écoulements permanents, turbulents et compressibles.

 

OpenFoam contient aussi ce qu'on appelle des "utilités standards", qui ont pour rôles la génération du maillage (blockMesh,extrudeMesh,...), la conversion et manipulation du maillage (ansysToFoam,fluent3DMeshToFoam,..), ainsi que d'autres outils pour le maillage et le post-processing (Post-processing graphics, Post-processing data converters,..)

De plus, des bibliothèques "bibliothèques standards" sont à la disposition de l'utilisateur qui permettent de choisir le modèle qui l'intéresse, par exemple :

  • Modèles thermodynamiques.

  • Modèles pour les réactions chimiques.

  • Modèles pour les transferts radiatifs.

  • Modèles pour la vitesse ​laminaire de flamme,...etc.

 

Comme chaque code de calcul a ses limites, OpenFOAM en possède aussi. La principale faiblesse de ce code est qu'il ne possède pas une interface graphique, ce qui demande de l'exprience pour se familiariser avec. Un autre défaut, est qu'il faut avoir linux pour installer OpenFOAM, ce qui peut être gênant surtout quand on dispose des logiciels qui ne sont que sur Windows.

Pour télécharger le logiciel, il suffit d'aller au site suivant : http://www.openfoam.org/download/ et suivre la démarche qui est bien détaillée.

Vous pouvez aussi trouver aussi sur ce site, des tutoriaux bien détaillés pour se familiariser avec le logiciel, comme vous pourrez allez sur la section "forum" où l'on peut poser des questions en relations avec le logiciel et où vous pourrez recevoir de l'aide et des conseils au cas où vous rencontrez des problèmes.

 

 

Fonctionnalités d'OpenFOAM

OpenFOAM est une bibliothèque rapide à mettre en place, large et évolutive, qui ne cesse jamais d'évoluer, puisque chaque utilisateur peut créer son propre solveur et son propre modèle. Ce code est un outil inédit qui a plusieurs fonctionnalités. Il permet à la fois de générer des maillages (ou de les importer), de faire de la CFD et offrir des outils pour la visualisation et le post-traitement des résultats.

 

1. Génération du maillage :  

Ce logiciel permet de générer des maillages non structurés à partir de deux outils :

  • blockMesh : générateur de maillage multi-block (c'est l'outil que nous utiliserons dans notre projet).
  • snappyHexMesh : Cet outil est très important et permet un raffinement de maillage automatique. 

OpenFOAM est capable d'utiliser des maillages faits avec d'autres mailleurs tels que SalomeAnsysCFX, Star-CD..                         

                                                         

  source: http://openfoam.org

2. Calcul CFD :

OpenFOAM en tant que code de calcul permet de résoudre un problème de mécanique des fluides via la méthode des volumes finis, quelque soit le problème étudié (stationnaire ou instationnaire, compressible ou incompressible, mono-phasique ou multi-phasique ..), en choisissant un solveur bien adapté au problème, en modifiant un solveur déjà existant ou même en créant un nouveau solveur qui décrit le mieux le problème étudié.

 

3. Post-traitement des résultats :

OpenFOAM fournit aussi des outils de post-traitement  et de visualisation des résultats, le plus utilisé est  Parafoam. Outil d'un grande utilité et puissance, qui permet de visualiser facilement les grandeurs qui intéressent l'utilisateur , leur évolution suivant n'importe quelle variables, et extraire les données désirées.

Après avoir présenté brièvement ce code de calcul ainsi que ses principales caractéristiques, nous allons par la suite expliquer en détail le fonctionnement de ce code, et  les différents étapes à suivre pour simuler un problème en mécanique des fluides sur ce logiciel.

                                                           

                                                                          source : http://vespalabs.org

Fonctionnement du code

 

Dans cette partie, nous allons expliquer en détail le fonctionnement d'OpenFOAM, les différents fichiers et dossiers qui permettent de lancer un calcul, ainsi que les différents outils de ce code.

Structure générale d'un cas OpenFOAM

Après avoir présenté le code OpenFOAM en général, nous allons à présent expliquer la logique de ce code pour bien appréhender sa hiérarchie.

Ce code est une bibliothèque C++, qui permet de créer des exécutables appelés applications/. Ce Code de calcul dispose d'énorme applications pré-compilées qui correspondent à toute catégorie de problèmes à étudier. L'une des questions fondamentales à se poser pour étudier un cas avec OpenFOAM, est celle de l'application (ou solveur) à utiliser. l'utilisateur n'a pas besoin de choisir les équations à résoudre, mais plutôt la bonne application à adopter (contrairement à Fluent par exemple). 

L'utilisateur peut bien créer sa propre application (ou solveur), avec bien évidemment une connaissance préalable de la physique du problème et les techniques de programmation, l'un des points forts d'OpenFOAM.

Les applications sont divisées en deux catégories :

  • Solvers : Conçus pour simuler un problème donné.
  • Utilities :  destinées pour la manipulation des données.

​​Les équations à résoudre sont codées dans ces applications.

Avec OpenFOAM, l'utilisateur n'a pas à sa disposition une interface graphique (contrairement à fluent par exemple) qui lui permet de rentrer les paramètres nécessaires pour lancer une simulation (Fluent par exemple), mais dispose plutôt d'un système de fichiers qui est plus au moins le même pour chaque solveur donné. La bonne maîtrise de ce système de fichiers est indispensable pour un utilisateur de ce code.La structure de ce système ainsi que l'utilité et la particularité de chaque dossier est illustrée dans l'arborescence suivante :

         

 

 

 

 

Description des fichiers

Le dossier 0

 

Ce dossier contient les valeurs initiales et les conditions limites des différentes grandeurs. Les conditions aux limites sous OpenFOAM est le point le plus délicat. Leur rôle dans la modélisation n'est pas simplement dans la géométrie, mais représentent une partie intégrale de la solution.  Dans cette partie nous allons nous focaliser sur ce point, et nous discuterons la façon dont elles sont traitées sous OpenFOAM. Chaque grandeur à résoudre (U,p,k...) par le solveur doit être initialisée sur toutes les zones du cas ainsi qu'à l'intérieur du domaine.

Il faut bien noter que toute frontière est généralement divisée en un ensemble de ce qu'on appelle "patch". Chaque patch peut contenir une ou plusieurs zones fermées de la frontière en question, qui ne sont pas nécessairement connectées physiquement.

Il y a trois attributs qu'on peut associer à un "patch" :

  • Base type : Cet attribut est purement géométrique. Il est défini dans le fichier boundary localisé dans le sous-dossier constant/polyMesh/. Il faut bien noter que pour cet attribut, tous les patches sont de type "patch", sauf ceux qui présentent une contrainte géométrique : empty, symmetryPlane, wall, wedge, cyclic,processor .

Brièvement nous allons expliquer ce que chaque type signifie.

patch : Concerne une frontière qui ne contient aucune information géométrique ou topologique (par exemple une entrée ou une sortie).

empty : Comme OpenFOAM ne génére que des maillages 3D, quand l'utilisateur veut résoudre un problème 2D, il faut spécifier une condition particulière vide sur les frontières qui nécessitent aucune solution.

cyclic : Permet de traiter deux patches comme étant connectés physiquement. Ceci est utile pour les géométries répétées (un faisceau de tubes par exemple).

processor : Cette option permet de diviser le maillage, afin que chaque partie soit traitée par un processeur si le code tourne en parallèle, ce qui est pratique pour les géométries compliquées avec un maillage très lourd.

Le fichier boundary qui contient cet attribut est de la forme suivante :                   

                      

 

  • Primitive et Derived type : Ces deux attributs sont spécifiés dans le dossier 0/ pour chaque grandeur. Bien évidemment ces types sont différents selon la grandeur. Une vitesse et une pression n'auront pas la même condition en la même frontière.

Il y a de nombreux types de zones possibles, les types classiques et leur description sont présentés dans le tableau suivant : 

    Type Description
fixedValue Valeur fixée par l'utilisateur.
zeroGradient Gradient normal à la zone nul.
fixedGradient Gradient normal à la zone fixé.
inletOutlet fixedValue lorsque la zone est une inlet et zeroGradient dans le cas contraire.
totalPressure La pression totale est constante, quand U changes, p est ajusté (vice-versa).

pressureInletVelocity

Quand p est connu à l'entrée, U est évaluée à partir du flux normal à la frontière en question.
pressureInletOutletVelocity Combinaison de pressureInletOutlet et InletOutlet.
calculated La grandeur est déduite des autres grandeurs.

Ces attributs sont présentées dans le dossier 0/ de la façon suivante (on considère la grandeur vitesse U) :

                     

 

 

Le dossier constant

 

Ce dossier contient les paramètres nécessaires pour le maillage et les constantes du problème (propriétés du fluide,....). 

La génération du maillage se fait dans le sous-dossier polyMesh/ et la définition des constantes du problème se fait dans des fichiers ...properties/.

 

Génération du maillage :

Avant tout il faut bien noter qu'OpenFOAM ne prend que des maillages 3D (Si le problème est 2D, il faut créer une maille d'épaisseur). 

Comme nous l'avons déjà mentionné, OpenFOAM offre deux outils de maillages : blockMesh et snappyHexMesh.

Le premier est destiné pour créer un maillage structuré à partir d'un ou plusieurs blocs géométriques juxtaposés les uns aux autres. Ce type de maillage se fait à partir du fichier blockMeshdict. BlockMesh lit ce fichier, génére le maillage et écrit les données du maillage : les fichiers pointscellsboundary dans le même répertoire constant/polyMesh/.

Le principe de cet outil est de décomposer la géométrie du domaine en un ou plusieurs blocs hexaèdriques tridimensionnels. Les bords des blocs peuvent être des lignes ou des arcs. Chaque bloc de la géométrie est définie par 8 sommets, un à chaque côté de l'hexaèdre. Il est possible aussi de générer des blocs de moins de 8 sommets (en repliant une ou plusieurs paires de sommets).

La structure du fichier blockMeshdict est par exemple :

                              

Cet outil est certes simple à manipuler, cependant, pour des géométries complexes, il s'avère impuissant et demande un travail et temps de calcul laborieux.

Le deuxième outil de maillage d'OpenFOAM (snappyHexMesh) permet quant à lui de modifier un maillage déjà existant (fait par exemple par blockMesh)  à l'aide d'une géométre surfacique.

Pour expliquer le principe de cet outil, on considère l'exemple suivant :

Nous voulons mailler un domaine autour d'une géométrie quelconque (avion, voiture ..), pour utiliser cet outil de maillage, il y a trois étapes à suivre :

  • Créer la géométrie de l'objet sous format STL (StereoLithography), binaire ou en ASCII qui se trouve dans le sous dossier constant/trisurface/ du cas étudié.
  • Créer un simple maillage de type blockMesh du domaine entourant l'objet .
  • Appliquer l'outil snappyHexMesh pour faire le reste, ce qui permet un processus de raffinement automatiquement et en un temps de calcul beaucoup plus par rapport à un autre logiciel de maillage.

Cet outil a plusieurs atouts intéressants : il permet de raffiner à l'endroit où l'utilisateur veut facilement, ainsi, il peut à l'entrée de cet algorithme imposer des critères de qualité du maillage, et qu'ils soient respecté dès le début en cours des itérations.

 

Les fichiers ...properties/  :

Ces fichiers permettent de renseigner le solveur quand aux propriétés de l'écoulement.

Nous pouvons classer ces fichiers en deux catégories :

  • Les fichiers  qui contiennent les propriétés physiques, thermiques et énergétiques de notre système, par exemple : TransportpropertiesmixturepropertiesThermophysicalmodel...

Exemple du fichier transportproperties (extrait de notre projet) :

                    

  • Les fichiers qui contiennent des informations sur la modélisation de la turbulence. Le fichier turbulenceproperties définie l'approche de modélisation adoptée (RANS,LES). Et si par exemple l'utilisateur choisit l'approche RANS, on spécifie dans le fichier RASproperties le modèle adopté (de même pour LES)

                  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Remarque Les coefficients qui interviennent dans un modèle de turbulence donné, sont par défaut définis. Cependant, l'utilisateur peut définir d'autres coefficients.

Le dossier system

 

Ce dossier contient trois fichiers indispensables pour lancer une simulation par OpenFOAM.

 

Le fichier Controldict 

Ce fichier permet de paramétrer le pas de temps et la création de la base de données. La syntaxe du fichier est la suivante :

                  

Tout le contenu de ce fichier est détaillé dans les lignes suivantes :

Application : Définie le solveur utilisé (par exemple : buoyantBoussinesqSimpleFoam).

Startfrom : Le type sur lequel le solveur va s'accrocher.

Starttime : Le temps pour lequel le solveur va s'accrocher pour commencer les itérations.

StopAt :  Détermine le type sur lequel le solveur va se baser pour arrêter les itérations.

endTime : Le temps au bout dulequel le solveur va s'arrêter.

deltaT : Définie le pas de temps de la simulation.

writecontrol : Détermine le type pour générer un dossier temporel, par exemple générer un dossier tous les n pas de temps "timestep" ou les n secondes simulées "runtime".

writeinterval : Détermine le nombre de pas de temps ou de secondes simulées entre deux dossiers temporels.

purgeWrite : Permet de préciser le nombre de dossiers temporels à garder sur le disque dur au fur et à  mesure des itérations.

writePrecision : Permet de paramètrer la précision des données de sortie (un autre avantage par rapport à fluent par exemple).

writeCompression : Permet de choisir si l'utilisateur veut générer des fichiers compressés en sortie ou non (gain de mémoire).

timeFormat : Permet de choisir le format des noms des dossiers temporels.

runTimeModifiable : Cette option intéressante permet de faire des modifications de ce fichier "controdict" en cours des itérations et instantanément.

 

Le fichier fvschemes 

Ce fichier permet de choisir les schémas numériques pour la résolution discrétisée des équations aux dérivées partielles. Dans ce fichier l'utilisateur détermine la méthode de résolution des opérateurs mathématiques (divergence, laplacian, gradient), ainsi que le type d'interpolation des valeurs. OpenFOAM offre un large choix que ce soit pour le type d'interpolation (default linear par exemple), ou pour le type de discrétisation.

Pour plus d'informations sur les différents schémas et la particularité de chacun, veuillez consulter le lien suivant:http://www.openfoam.org/docs/user/fvSchemes.php#x20-1070004.4

 
Le fichier fvSolution 
 
Le fichier fvSolution permet de préciser les critères de convergence des différentes grandeurs. En effet, dans ce fichier l'utilisateur peut fixer le solveur pour la discrétisation d'une grandeur donnée, la tolérance ainsi que les algorithmes de contrôle.
La tolérance représente la valeur du résidu à partir duquel les itérations cessent.
Le relTol représente le rapport du résidu final sur le résidu initial en dessous duquel les itérations s'arrêtent. En général ce paramètre est nul, ce qui veut dire que le résidu descend en dessous de la tolérance.
Avant de résoudre une équation pour une grandeur donnée, le résidu initial est basé sur les valeurs existantes de cette grandeur. Après chaque itération, le résidu est réévalué. les itérations s'arrêtent si l'une des conditions suivantes est remplie :
  • Le résidu est inférieur à la valeur de la tolérance du solveur.
  • Le rapport du résidu courant sur le résidu initial descend en dessous du relTol.
  • Le nombre d'itérations dépasse un nombre maximum maxiIter.

​​Ce fichier se présente sous OpenFOAM de la façon suivante :

       

​Pour plus d'informations, veuillez consulter le lien suivant :http://www.openfoam.org/docs/user/fvSolution.php

Outil de visualisation et Post-traitement

Le principal outil de post-traitement fourni par OpenFOAM est Parafoam. Cet outil open source est en fait un script qui lance le module de lecture fourni par OpenFOAM. Il est exécuté comme l'un des utilities d'OpenFOAM seulement en tapant la commande parafoam dans le dossier du cas en question.

Cet outil s'avère très puissant, il permet d'afficher les champs, les vecteurs, les contours, les lignes de courants, ainsi, permet-il facilement de créer des animations et de suivre l'évolution d'une grandeur donnée le long le long d'une ligne quelconque dans le domaine d'étude. Il est également facile d'extraire sous format colonne et les exporter pour les traiter par un autre outil (matlab par exemple).                                                                                                                                                                                  

                                 

                                                                             source :http://hanchagroup.wordpress.com                              

 

OpenFOAM permet aussi d'accéder aux résidus au cours des itérations pour chaque grandeur à résoudre .

Pour ceci, il suffit de taper la commande suivante dans le dossier du cas à étudier  : 

> pyFoamPlotRunner.py buoyantBoussinesqSimpleFoam     

Dans ce cas nous avons mis à titre d'exemple le nom du solveur buoyantBoussinesqSimpleFoam, dans un autre cas, il faut simplement mettre le nom du solveur correspondant.

Conseils importants

Dans cette partie, nous allons vous présenter quelques conseils utiles, pour surmonter quelques difficultés que l'utilisateur peut rencontrer en utilisant OpenFOAM, ainsi que quelques outils pratiques.

- Il faut toujours faire attention aux dimensions des grandeurs, sinon une mauvaise unité risque de donner des résultats aberrants sans se rendre compte de l'origine de l'erreur.

- Choisir le bon solveur, qui colle le mieux avec le cas d'étude.

-Prendre le maximum du temps pour la définition des conditions limites, elles présentent le grand souci sur OpenFOAM.​​​​​​​

-Après la création du maillage, il faut toujours le vérifier grâce à la commande checkMesh. Pour des géométries complexes, il vaut mieux faire le maillage avec un autre logiciel (Salome, ICEMCFD,..etc), et l'exporter par la suite via des commandes. (voir http://www.openfoam.com/features/mesh-conversion.php).

-Le problème de divergence des résultats sur OpenFOAM n'est pas explicitement indiqué, mais s'affiche plutôt le message d'erreur suivant :Exception en point flottant.

Ce problème de divergence peut avoir plusieurs sources : Conditions aux limites mal définies, nombre de courant mal respecté, solveur mal choisi, maillage non adapté. En général, il suffit d'étudier le compte-rendu des itérations (en remontant dans la console ou en lisant le fichier log) .

La stratégie à suivre pour faire ou modifier un cas pré-existant

 

Nous présenterons dans ce qui suit deux cas simples d'applications du code OpenFOAM.

 

Tout d'abord, le premier cas correspond au cas test de la cavité entraînée, en démontrant pas à pas les différentes étapes à franchir afin de mettre en place un simulation numérique sur OpenFOAM. Puis, nous étudierons un cas plus complexe, celui d'une chambre chauffée par le bas, pour montrer comment on peut comprendre une simulation sur tutoriel avec un solveur plus complexe, et comment, à partir de là, on peut adapter notre projet.

Cas test 1 : Cavity

Dans ce qui suit, nous nous inspirerons essentiellement les conseils donnés sur les sites  suivants:

http://www.openfoam.org/docs/user/cavity.php#x5-40002.1

http://openfoamwiki.net/index.php/How_to_add_temperature_to_icoFoam

Néanmoins, nous tenterons d'effectuer une synthèse ainsi que de souligner notamment les difficultés que l'on pourrait rencontrer. Aussi, dans le prolongement de la cavité entraînée, nous traiterons également de l'ajout d'une équation de température (et on traitera alors de la convection Rayleigh-Benard).

 

 

Tout d'abord, en cas de modification apporté à un tutoriel de base, il faut absolument éviter de modifier directement le cas de base qui constitue une référence. Tout d'abord il convient de créer un répertoire de travail personnel dans lequel effectuer nos modifications en utilisant la commande suivante :

> mkdir -p /work/username/OpenFOAM/username-${WM_PROJECT_VERSION}/run

Puis, il est conseillé de copier les exemples du tutoriel qui se trouvent normalement dans les sources, soit depuis $WM_PROJECT_DIR/tutorials  vers le dossier /work/username/OpenFOAM/username-${WM_PROJECT_VERSION}/run.

Enfin, il ne reste plus qu'à se placer dans les tutoriels dans le solveur de notre choix, pour tester les différents cas test proposés.

 

Dans ce qui nous intéressera dans les prochains paragraphes, on cherchera plutôt à étudier et modifier un cas déjà existant de cavité entraînée, auquel on accède rapidement en entrant la commande suivante :

> cd /work/username/OpenFOAM/username-${WM_PROJECT_VERSION}/run/tutorials/incompressible/icoFoam/cavity

Remarque : ce faisant, on se place dans le fichier de base copié pour le solveur icoFoam, que l'on peut exécuter immédiatement. Toutefois, il serait préférable de copier le dossier cavity au sein même de icoFoam  pour chaque nouvelle modification que l'on apportera.

Cas de la cavité entraînée

 

Tout d'abord, on peut se servir d'un modèle déjà existant pour se faire une idée de la mise en place d'une simulation numérique sous OpenFOAM.

Notre objectif est d'effectuer la simulation numérique du cas suivant :

 

           Figure : Geometry of the lid driven cavity

source : http://www.openfoam.org/docs/user/cavity.php#x5-40002.1

Nous nous plaçons dans le cas d'un écoulement incompressible, d'un fluide Newtonien, en régime laminaire transitoire. Cela correspond au solveur icoFoam que nous utiliserons.

 

 

Tout d'abord, avant de commencer l'étude d'un cas sur OpenFOAM dans un terminal donné, taper la commande : 

> source /mnt/hmf/OpenFOAM/OF21.sh

Sans cela, il se peut que des commandes que l'on appliquera ultérieurement ne soient pas reconnues. Cette commande n'est valide que sur le terminal utilisé, et sera à entrer sur tout nouveau terminal.

Pour étudier ce cas, nous partirons des tutoriaux, qui sont déjà prêt à être lancés. Par conséquent, nous utiliserons la commande suivante pour nous rendre à l'emplacement voulu :

> cd $FOAM_RUN/tutorials/incompressible/icoFoam/cavity

Puis, il possible de directement lancer le cas test avec :

> icoFoam

Enfin, nous pouvons observer les résultats suivant :

> paraFoam

 

Figure : Obtention des résultats d'une simulation existante pour un cas de cavité entraînée

Remarque : le 'Time' indiqué représente le temps physique auquel on est parvenu pour la simulation.

 

 

 

 

Ajout de l'équation de température

Dans ce qui suit, nous nous inspirerons essentiellement des conseils donnés sur le site suivant (en établissant toutefois une synthèse de ce que nous connaissons également pour ne retenir que ce qui reste le plus utile) :

http://openfoamwiki.net/index.php/How_to_add_temperature_to_icoFoam

 

Aussi, nous nous servirons du cas de la cavité entraînée que nous modifierons : en effet, on mettra la vitesse de la plaque du haut à 0 m/s, et nous verrons par la suite comment imposer des températures sur les faces voulues.

Il s'agit d'une modification apportée sur un cas simple, pour un solveur assez simple donné. Ce genre d'ajout peut être bien plus difficile à adapter suivant le solveur employé. Néanmoins, même dans ce cas simple, des modifications non négligeables doivent être apportées au niveau des fichiers sources du répertoire copié.

 

Création du répertoire source modifiable

 

Tout d'abord, il faut se placer au niveau du répertoire run/ dernièrement établi, et y créer le répertoire applications/solvers, comme c'est indiqué par les commandes ci-dessous :

> cd /work/username/OpenFOAM/username-{WM_PROJECT_VERSION}/run

> mkdir -p applications/solvers

> cd  applications/solvers

Puis il faut aller chercher dans les fichiers sources le solveur voulu à copier dans le répertoire solvers/. Par exemple, on copiera le répertoire icoFoam/ sous le nom de exe_icoFoam/, comme c'est indiqué dans les lignes suivantes, pour le cas particulier de la configuration des ordinateurs à l'ENSEEIHT :

> cp -r /mnt/hmf/OpenFOAM/OpenFOAM-2.1.0/applications/solvers/incompressible/icoFoam exe_icoFoam
 

Puis, en se plaçant dans exe_icoFoam/, on trouve divers fichiers d'extension .C, .H, et un dossier Make/. Il convient tout d'abord de détruire comme il suit :

> rm icoFoam.dep

et de renommer comme il suit :

> mv icoFoam.C exe_icoFoam.C

Puis, dans le dossier Make/ :

> rm -rf linuxGccDP0pt

De plus, il ne faut pas oublier de changer dans le fichier files les lignes avec 'icoFoam' en :

exe_icoFoam.C

EXE = $(FOAM_USER_APPBIN)/exe_icoFoam

Finalement, on peut vérifier que l'installation renommée marche à l'aide de la commande :

> wmake

Aussi, si tout a bien fonctionné, un fichier nommé exe_Foam devrait apparaître au niveau du répertoire suivant :

> ls $FOAM_USER_APPBIN

 

 

Modifications à apporter au niveau du code source

 

Une fois que l'on a  effectué ces modifications, il convient à présent d'ajouter les champs de température au coeur même des équations à résoudre. Ainsi, en ouvrant le fichier createFields.H, on aura :

                                               

Puis, après avoir ajouté la grandeur température à l'ensemble des grandeurs résolues, on implémente désormais la nouvelle équation à résoudre en ouvrant le fichier exe_icoFoam.C et en procédant comme indiqué ci dessous :

                               

 

Attention ! Ce travail terminé, enregistrer les résultats, et exécuter dans exe_icoFoam/ la commande  :

> wmake

Si aucun message d'erreur apparaît, on peut procéder aux modification au sein du fichier du cas étudié.

 

Modifications à apporter au sein du fichier du cas étudié

 

Il est tout d'abord fortement recommandé de copier le cas étudié, par exemple dans notre cas le dossier cavity/ qui se trouve dans usernamel/OpenFOAM/username-2.1.0/run/tutorials/incompressible/icoFoam ("username-2.1.0" car la version d'OpenFOAM utilisée est ici 2.10), dans le répertoire run/ de l'arborescence de fichiers manipulée, et peut-être de le renommer cavity_T/

Puis, en se plaçant dans cavity_T/, aller dans le répertoire constant/ et ajouter les lignes suivantes dans le fichier transportProperties :

DT            DT [0 2 -1 0 0 0 0] 0.002;

Cette ligne s'ajoute à la suite de la ligne sur la viscosité cinématique, avec la même structure. Pour l'instant, la valeur numérique importe peu.

Enfin, aller dans le répertoire 0/ et créer le fichier T comme il suit :

                                            

Remarque : il est important de bien retrouver les noms des faces définies dans le fichier blockMeshDict. Quand aux conditions limites, nous avons ici repris l'exemple qui est communément répété.

Enfin, en allant dans le répertoire system/, il y a deux dernier fichiers à modifier. 

Le fichier fvSchemes de la manière suivante :

Et le fichier fvSolution :

 

 

Quand tout ce travail est fini et sauvegardé, il suffit de se placer dans cavity_T/, et d'exécuter les commandes :

> source /mnt/hmf/OpenFOAM/OF21.sh                 (si cela n'a pas déjà été fait)

> blockMesh                                                                 (juste pour être sûr)

> exe_icoFoam

Si aucun message d'erreur apparaît, il doit être possible d'observer les résultats obtenus via paraFoam.

Cas test 2 : Hot Room

Dans le cas suivant, nous exécuterons le cas test du solveur dont nous nous servirons ultérieurement pour notre projet. Il s'agit de buoyantBoussinesqSimpleFoam, et nous testerons le cas de la chambre chaude (hotRoom/).

Aucune modification au niveau des équations du solveur utilisé n'étant requise, nous nous placerons pour cette simulation dans le répertoire buoyantBoussinesqSimpleFoam/, situé au niveau de : tutorials/heatTransfer/. Puis, nous copierons le répertoire hotRoom/ pour ensuite l'exécuter directement (en tapant : > buoyantBoussinesqSimpleFoam).

 

Premières erreurs possibles

Les premières difficultés surviennent lorsqu'un message d'erreur s'affiche expliquant qu'il ne peut trouver le fichier T. Le plus simple pour nous est de copier le fichier T.org situé dans 0/ en T, et éventuellement de modifier certaines valeurs si on le souhaite.

De plus, on s'aperçoit que, au cours de modifications mineures comme un insignifiant changement au niveau du maillage (passage d'un maillage de 20x20x40 à 40x40x80,  par exemple), le calcul divergeait purement et simplement ! Ce problème réside au niveau du pas de temps fixe, que l'on peut ajuster au niveau du fichier controlDict, dans le répertoire system/. Il convient de manière générale de respecter la règle du nombre de CFL (ou nombre de Courant Friedrichs Lewy), qui se résume à :

$ CFL = \frac{U \delta_{t}}{\delta_{x}} $ , et $ CFL < 1$, en tout point.

Avec U étant la norme de la vitesse (principalement suivant la direction $\overrightarrow{x}$),  $\delta_{t}$ étant le pas de temps, et $\delta_{x}$ l'intervalle entre 2 mailles.

 

Réglage de la précision pour la simulation numérique

Aussi, il conviendra pour la suite de choisir une tolérance convenable pour nos calculs. Suivant l'échelle et la précision avec lesquelles on travaille, il peut être bon de modifier le facteur de convergence au niveau des résidus, dans le fichier fvSolution, dans system/, comme c'est indiqué ci dessous :

 

Ici, on prend une précision à 10-6 en guise d'exemple, et parce que c'est ce  qui se prête le plus à nos travaux.

En effet, si la convergence mentionnée est atteinte trop tôt, le calcul s'arrêtera même si l'on a pas atteint le temps physique voulu, ou même si la situation semble continuer à évoluer à l'oeil nu sur paraFoam pour certaines grandeurs physiques. Il est donc important de prêter attention à la précision désirée, mesurable par le biais des résidus obtenus.

 

Comment relancer une simulation à partir d'un instant donné ?

Finalement, dans le cas où une simulation est interrompue trop tôt ou voudrait être poursuivie pour un temps physique plus long, il est assez simple de repartir du dernier temps enregistrer sur OpenFOAM : en effet, il suffit d'ouvrir le fichier controlDict situé dans system/, et de modifier la valeur du 'startTime' pour le faire commencer à la dernière itération enregistrée (c'est le nom du dernier fichier créé dans le répertoire du cas étudié), ainsi que la valeur de 'endTime' pour le faire terminer au temps physique voulu.