Validation du solveur open-source OpenFOAM pour la résolution de problèmes thermiques

 

 

Réalisé par :                                              BEN ABBES Amira

​                                                              3ème année, Energétique

                                                        amira.benabbes@etu.enseeiht.fr

                                                                     SOUBSOL David

                                               3ème année, Mécanique des fluides numériques

                                                            david.soubsol@etu.enseeiht.fr

                                                                         HASSI Tarik

                                                               3ème année, Energétique

                                                               tarik.hassi@etu.enseeiht.fr

 

 

      Encadrants :         

                                                - LEGENDRE Dominique

                                                - PEDRONNO Annaig

                                                - NEAU Hervé

 

        Contacts entreprise :   

                                               - CHARALABIDIS Damien         

                                               - DOUCET Mathieu                          

 

 

ANNEE 2012/2013

ENSEEIHT, Département Hydraulique et Mécanique des fluides

 

Présentation générale

      Bonjour,

       Nous sommes heureux de vous accueillir sur le site présentant notre projet long en école d'ingénieur, qui s'inscrit dans le cadre des bureaux d'études industriels (BEI).

Ce projet a été réalisé par des étudiants de l'ENSEEIHT (Ecole Nationale Supérieure d'Electronique, d'Electrotechnique, d'Informatique, d'Hydraulique et de Télécommunication de Toulouse) :

                     -  HASSI Tarik, Hydraulique et Mécanique des fluides, Energétique

                     -  BEN ABBES Amira, Hydraulique et Mécanique des fluides, Energétique

                     -  SOUBSOL David, Hydraulique et Mécanique des fluides Numérique, Energétique

Nos encadrants sont LEGENDRE Dominique, PEDRONO Annaig et NEAU Hervé, enseignants à l'ENSEEIHT, ainsi que CHARALABIDIS Damien et DOUCET Mathieu, nos contacts en entreprise.

Nous traiterons d'un sujet proposé par l'entreprise ALTRAN, dans l'optique de valider qualitativement et quantitativement la version 2.1 du logiciel OpenFOAM pour certaines situations particulières. Dans notre cas, nous étudierons une couche limite verticale engendrée par la convection naturelle. Ce cas d'étude fait partie des cas de la base de données ERCOFTAC (European Research Community On Flow, Turbulence and Combustion database) , plus précisément le cas numéro 9.

 

 

 

 

 

 

 

 

Présentation de notre partenaire industriel : ALTRAN

 

SOURCE : http://www.altran.com/

ALTRAN est une entreprise de sous-traitance en ingénierie dans des domaines divers et variés (électronique, qualité, organisation, etc ...). Fondée en 1982 en France, c'est aujourd'hui un des leaders européens du conseil pour ce qui a trait aux hautes technologies sur l'ensemble des métiers de l'ingénierie.

 

Implantée dans 30 pays différents, elle se démarque notamment lors des processus d'innovation pour ses clients. Fin 2011, son chiffre d'affaire était de 1420 millions d'euros et 17261 salariés travaillaient en son sein.

 

Présentation d'ERCOFTAC

ERCOFTAC est une base de données  qui a été crée en 1995, gérée par un groupe de recherche en Mécanique des fluides, Turbulence et CFD à l'université de Manchester.  

                                                                               

                                                                                             source:http://sig42.group.shef.ac.uk

Cette base de données contient des cas tests, chaque cas contient une description, des données à télécharger, des références à des travaux publiés..etc.

L'association ERCOFTAC est un leader européen, basée sur l'association de groupes de recherche, d'enseignement et de l'industrie de la mécanique des fluides, la turbulence et la combustion.
La mission principale de cette association est de définir une stratégie de partage, de recherche et de connaissance en mécanique des fluides, en turbulence et en combustion.

Les objectifs principaux d'ERCOFTAC sont :

  • Encourager les instituts de recherche et les industries en mécanique des fluides, turbulence et combustion, afin d'assurer un échange scientifique et technique.
  • Établir des contacts avec la communauté internationale en mécanique des fluides.

L'association ERCOFTAC est très active en Simulation des Grandes Echelles, en modélisation de  Turbulence (compressible et incompressible), en écoulement polyphasique, en milieux réactifs (combustion),...etc.

Pour plus d'informations, veuillez consultez le lien suivant : http://www.ercoftac.org.

Sujet d'étude

 

Nous traiterons l'étude d'une couche limite développée par convection naturelle sur une plaque chauffante verticale. On considèrera un cas bidimensionnel.

L'allure du domaine étudié est la suivante :

 

 Figure 1

L'image précédente est un agrandissement du cas général suivant:

                                                                        Figure 2                                               

 

En effet, la plaque chauffante est verticale (suivant l'axe des x, notons le) et mesure 4 mètres de long. On voit se développer, entre x=0 m et x=0.8 m environ, une couche limite laminaire, laquelle devient turbulente vers : x=0.8 m. Aussi, on se placera en régime pleinement turbulent pour résoudre notre cas. Nous disposons de données expérimentales qui nous permettront d'injecter en entrée (voir figure 1) un profil de vitesse et un profil de température. Ces derniers seront indépendants du temps. Nous vérifierons ainsi dans un premier temps nos résultats de manière qualitative, avant de comparer les résultats numériques avec les résultats détaillés obtenus par l'expérience, et donc de vérifier ces résultats de manière quantitative.

 

 

                                                   

 

 

 

 

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.

 

Projet : La convection naturelle le long d'une plaque verticale

Calcul numérique ERCOFTAC : Mise en place de la simulation numérique

Nos premières simulations on été effectuées pour représenter uniquement la géométrie introduite par le site ERCOFTAC (cas 09).

Ainsi, notre domaine de calcul se réduira à la zone où la couche limite turbulente est pleinement développée.

 

 

 

 

 

 

Analyse théorique et étude préliminaire

Dans cette partie, nous présentons les équations analytiques qui permettent de décrire ce problème de couche limite turbulente.

Pour simplifier le problème, nous ferons les hypothèses les hypothèses suivantes :

  • On considère que le problème est 2D plan $ \Rightarrow$ $  \frac{\partial} {\partial z} =0 $ et Uz=0.
  • On considère que le problème est stationnaire $ \Rightarrow$ $ \frac{\partial} {\partial t} =0 $.
  • On suppose que l'air est un gaz parfait.
  • On considère que l'écoulement suit l'hypothèse de Boussinesq, i.e les propriétés du fluide (l'air) sont constantes, sauf la masse volumique $ \rho $ dans le terme des forces de volume (la gravité) qui ne dépend que de la température T.

          $ \frac{\rho}{\rho_r} = 1 - \beta (T-T_r) $

Avec :   $T_r$  : La température de référence, pour notre cas $T_r = 15°C $

              $\rho_r$ : La masse volumique de référence.

              $\beta $ : Le coefficient de dilatation thermique (en K-1)
 
Par définition, $\beta = - \frac{1}{\rho} \frac{d \rho}{d T}(T=T_r)$ , pour un gaz parfait (notre cas) $\beta =\frac{1}{T_r} $ .
A.N     $\beta = 3.47 1e-3 $
  • On suppose que $ \frac{\partial} {\partial y} >>  \frac{\partial} {\partial x} $ .

Avec ces hypothèses, les équations de conservation en couche limite en convection naturelle sont :

L'équation de continuité :

               $ \frac{\partial U} {\partial x} +  \frac{\partial V} {\partial y} =0 $

L'équation de conservation de quantité de mouvement :

$ U \frac{\partial U} {\partial x} + V \frac{\partial U} {\partial y}  =  \frac{\partial }{\partial y} (\nu \frac{\partial U}{\partial y})+ g \beta (T-T_r) $

Quant à l'équation de l'énergie (ou de la température), puisqu'en convection naturelle, l'écoulement est à faible nombre de Mach (vitesses faibles associées à la convection naturelle), donc pas de terme de dissipation, par suite cette équation donne :

L'équation de l'énergie :

$ U \frac{\partial T} {\partial x} + V \frac{\partial T} {\partial y}  = \frac{\partial  }{\partial y} (\alpha ​\frac{\partial T}{\partial y}) $

On remarque bien que le terme de flottabilité couple le problème hydrodynamique et le problème thermique. Certes le modèle de Boussinesq complique le problème par rapport à celui du problème incompressible, mais c'est beaucoup plus simple que celui compressible.

Nous pouvons à ce stade, mener une étude dimensionnelle pour quantifier les paramètres adimensionnels qui contrôlent notre problème. En adimensionnalisant les équations précédentes, on voit bien l'apparition du fameux nombre de Grashof   : $ Gr_L=\frac{\beta g L^3 (T_w-T_a)}{\alpha^2} $. Ce nombre qui compare l'effet des forces de flottabilité à celui des forces visqueuses, joue le même rôle que celui du nombre de Reynolds en convection forcée. Et donc pour comparer l'effet de la convection naturelle à celui de la convection forcée, il suffit de comparer le nombre de Grashof et la racine du Reynolds.

 

Modélisation de la turbulence :

Pour modéliser la turbulence, nous allons nous baser dans un premier temps sur la résolution RANS. Cette approche consiste à moyenner les équations précédentes (moyenne d'ensemble) en utilisant la décomposition de Reynolds.

​Avec les mêmes hypothèses précédentes, on obtient :

L'équation de continuité :

$ \frac{\partial \mathbf{U}} {\partial x} +  \frac{\partial \mathbf{V}} {\partial y} =0 $

L'équation de conservation de quantité de mouvement :

$ \mathbf{U} \frac{\partial \mathbf{U}​ } {\partial x} + \mathbf{V} \frac{\partial \mathbf{U}} {\partial y}  =  \frac{\partial}{\partial y} (\nu \frac{\partial \mathbf{U}}{\partial y} - \overline{u' v'})+ g \beta (\mathbf{T}-T_r) $​

L'équation de l'énergie :

$ \mathbf{U} \frac{\partial \mathbf{T}} {\partial x} + \mathbf{V} \frac{\partial \mathbf{T}} {\partial y}  = \frac{\partial  }{\partial y} (\alpha ​\frac{\partial \mathbf{T}}{\partial y} - \overline{v' T'}) $

Les grandeurs en gras représentent des grandeurs moyennes, les termes en ' représentent les fluctuations.

Le long de ce projet, nous allons adopter l'approche RANS. Cependant, nous allons tester plusieurs modèles de turbulences : k-epsilon, k-epsilon RNG, RSM,...etc

Création du maillage

Maillage sous SALOME

La plate-forme SALOME est principalement développée par le CEA et EDF, celle ci permet de créer et mailler des géométries, ainsi que de modifier les propriétés numériques et physiques d'éléments géométriques et enfin de visualiser et post-traiter des champs de résultats. Cet outil est open-source, c'est pour cette raison que nous réalisons notre maillage avec, puisque l'integralité de la chaîne de calcul doit être libre.

On réalise ainsi un premier maillage régulier et uniforme (1cm la maille) de la géométrie présentée précédemment. 

Ensuite nous effectuerons un raffinement, avec un ratio 10, au niveau de la zone proche paroi et ce afin de bien représenter la couche limite qui se développe autour de la plaque chauffée.

Maillage sous OpenFOAM

Ce même maillage peut se faire directement sous OpenFoam puisque la géométrie est assez simple à construire, ceci en modifiant le fichier BlockMeshDict du cas test Cavity, mais cette fois-ci en raffinant aux parois avec un ratio 10.

   

 

Pour nos simulations, nous allons utiliser plusieurs maillages avec des ratios différents, afin d'analyser d'une part améliorer les résultats, et d'autre part, analyser son effet sur la qualité de ces résultats.

Paramètres de simulation

Conditions initiales

L'entrée

La difficulté principale de ce calcul est liée au choix de configuration, où l'entrée n'est plus libre, puisque elle est positionnée à 1.4 mètres en dessus du bord d'attaque. Il faut donc imposer en entrée, des profils non uniformes en vitesse ainsi qu'en température, issus des mesures expérimentales que nous représentons ci-dessous.

Il est à noter que ces données représentent un intervalle allant de 0 jusqu'à 12 cm à partir de la plaque verticale, sans pour autant donner des plus informations sur le reste du domaine d'entrée. Il va donc falloir choisir un profil qui représente plus ou moins ce qui se passe d'un point de vu dynamique et thermique.

Ainsi, nous imposons des profils linéaires qui relient les dernières valeurs données expérimentalement en y=0.12 m jusqu'à T=288.15K et U=1e-4m/s, en y=0.5 m.

NB: Le profil imposé en entrée doit coïncider avec les positions des points du maillage. Pour ce, nous effectuons des opérations d'interpolation via un programme Matlab qui permet de réaliser cette opération quelque soit la maillage mis en plaque.

 

Conditions limites

Le choix des conditions aux limites aux niveaux de la sortie et du bord de gauche, n'a pas été évident. Plusieurs essais ont été mis en place avant d'avoir choisit les bonnes BC qu'on résume dans le tableau ci-dessous.

  Entrée Plaque Sortie Bord
U (m/s) nonuniform List<vector>

fixedValue uniform (0 0 0)

zeroGradient zeroGradient
p (Pa) zeroGradient zeroGradient

fixedValue uniform

fixedValue uniform
T (K) nonuniform List<scalar>

fixedValue uniform 333.15K

zeroGradient zeroGradient

 

Mise en place des calculs

La mise en place de ce calcul, nécessite d'abord la création d'un répertoire contenant les fichiers où seront décrits les différents paramètres physiques et numériques, indispensables pour la simulation.

Pour ce, nous nous place dans le répertoire /heatTransfer/buoyantBoussinesqSimpleFoam où nous pouvons copier le tutoriel hotRoom sous un nouveau nom  > cp  -r  hotRoom  plaque, et comme pour tout calcul sous OpenFOAM, nous modifions les fichiers correspondants aux paramètres physiques, contenus dans les répertoires 0 > gedit 0/* & , ainsi que les paramètres numériques contenus dans /systeme, sans oublier de vérifier le maillage, les propriétés thermophysiques, le sens de la gravité et le modèle de turbulence, dans le répertoire /constant.

 

Une première tentative de mise en place du calcul, avec les profils de vitesse et de température non-uniforms en entrée, n'aboutit finalement pas et l'on obtient le message d'erreur ci-dessous:

--> FOAM FATAL ERROR : Continuity error cannot be removed by adjusting the outflow.

Please check the velocity boundary conditions and/or run potentialFoam to initialise the outflow.

Cette erreur est due à une discontinuité entre le profil des vitesses, non nul, imposé en entrée avec la condition dans le le domaine intérieur: internalField U (0 0 0).

Pour résoudre ce problème de discontinuité, nous passons par une étape intermédiaire, qui revient à lancer un nouveau calcul via le solveur potentialFoam.

 

Calcul sous PotentialFoam

PotentielFoam est un solveur d'écoulement potentiel qui peut être utilisé pour initialiser le domaine et résoudre tout problème de discontinuité.

Il suffit donc de se placer dans basic/potentialFoam/, de copier le cas "cylinder" sous un nouveau nom et ensuite récupérer le fichier des vitesses U crée précédemment.

Les résultats de ce calcul doivent être copiés dans le répertoire 0 du calcul sous buoyantBoussinesqSimpleFoam.

 

Calcul sous buoyantBoussinesqSimpleFoam

  • Calcul en parallèle

Il est relativement facile de faire fonctionner un calcul en parallèle, sur plusieurs processeurs. Il convient tout d'abord de copier le fichier decomposeParDict dans le dossier system du cas de calcul

> cd system

>  cp OpenFOAM/user/run/tutorials/multiphase/interFoam/ras/damBreak/system/decomposeParDict

Le fichier decomposeParDict peut être détaillé de la façon suivante :

Pour obtenir davantage de renseignements, le site suivant permettra de fournir davantage d'explications (notamment sur la manière de faire du calcul en parallèle en utilisant plusieurs machines d'un même réseau) :

http://www.openfoam.org/docs/user/running-applications-parallel.php#x12-820003.4

Dans notre cas, nous utiliserons directement le fichier copié tel quel, puisque nous voulons travailler en utilisant pour une unique simulation les 4 processeurs d'une même machine.  Ainsi, il convient de faire :

> cd nom_du_cas

> decomposePar

A ce stade, des dossiers processor*/ ont du apparaître. On vient de partager les domaines voulus sur les quatre processeurs. Enfin, on lace le calcul avec la commande générale :

mpirun --hostfile <machines> -np <nProcs> <foamExec> <otherArgs> -parallel > log &

Soit, dans notre cas simple :

> mpirun -np 4 buoyantBoussinesqSimpleFoam -parallel > log &

 

On peut surveiller l'évolution du calcul en surveillant l'évolution du fichier "log", en entrant :

> tail -f log

Une fois que le calcul est terminé, il faut rassembler les résultats :

> reconstructPar

 

On obtient maintenant les divers répertoires pour les différents temps physiques voulus, et on peut exécuter le post-traitement habituel avec :

> paraFoam

 

  • Convergence de la simulation:

Afin de vérifier la convergence de la simulation, un calcul des résidus peut se faire via la commande:

> pyFoamPlotRunner.py buoyantBoussinesqSimpleFoam

 

Présentation des résultats

Après convergence du calcul et atteinte du régime permanent, nous visualisons nos résultats sur paraview.

 

Vitesse (m/s)


Température (°C)


Lignes de courant (vitesse)

 

La visualisation sur paraview permet donc de valider ne serait ce que qualitativement les résultats de nos calculs.

Difficultées rencontrées lors de l'implantation des conditions limites

Il est tout d'abord extrêmement difficile de bien comprendre la signification des conditions limites proposées sur OpenFOAM. Dans notre cas, seuls de long essais nous ont permis de déterminer une fois pour toutes les conditions limites à utiliser pour nos simulations. L'implémentation des conditions limites fut la partie la plus longue du projet.

Cependant, les simulations dans leur ensemble étaient particulièrement difficiles à mettre en place, notamment pour les profils à l'entrée. Les valeurs expérimentales données permettaient d'établir un profil de vitesse ou de température, pour certains points donnés seulement. Notre maillage ne s'adaptant pas forcément exactement avec ces points, il a fallut effectuer une interpolation à partir des données expérimentales afin de trouver un profil à injecter qui convienne à notre maillage.

Malheureusement, ce problème en entraîna un autre : avec un profil de vitesse non-nulle en entrée et une vitesse nulle dans tout le reste du domaine, OpenFOAM s'avère incapable de s'adapter, et finit par s'arrêter sur ce qu'il nomme une : "discontinuity error". Cela impliquera dans notre cas de passer par un autre solveur, potentialFoam, pour obtenir des champs de vitesse dans tout le domaine, champs que OpenFOAM pourra accepter. Il nous faudra finalement injecter ces données dans le cas en cours pour parvenir à faire marcher la simulation.

 

Finalement, tout semble marcher pour le mieux lorsque l'on trace les profils de vitesse à l'entrée :

 

 

Il faut finalement accepter le fait que potentialFoam déforme le profil de vitesse à l'entrée (qui, après interpolation, se superpose exactement avec le valeurs expérimentales qui sont les conditions limites imposées).

Ce dernier problème n'a pu être résolu, en partie parce qu'il ne fut découvert que tardivement. Il faut donc garder à l'esprit que les simulations suivantes présenteront à la base ce genre de défaut ...

Calcul numérique ERCOFTAC : Exploitation des résultats

Etude de l'influence du modèle de turbulence utilisé

 

Bien que la plupart des premières expériences aient été menées avec un modèle de turbulence k-epsilon classique, et en utilisant des valeurs de grandeurs turbulentes prises comme ordre de grandeur par défaut, nous nous sommes penchés sur le modèle de turbulence dès que le besoin d'améliorer quantitativement nos résultats s'est fait sentir. Cela fut le cas après avoir établi les bonnes conditions limites qui permettaient un bon fonctionnement d'un point de vue qualitatif.

Ainsi, de nombreux modèles de turbulence ont été testés, et parmi eux, le modèle RNGk-epsilon, qui est l'un des modèles qui dérivent de k-epsilon. En effet, il consiste en une modification du terme de dissipation, plus précisément le terme de production. Cette modification a pour but de prendre en compte même les petites échelles de l'écoulement, et non seulement les grandes échelles comme pour le modèle k-epsilon standard. L'équation de k reste inchangée.

Les résultats obtenus, toujours en les comparant avec la référence expérimentale, sont affichés pour les différentes hauteurs 1.918m, 2.535m et 3.244m. Le maillage utilisé pour de telles simulations est de 500x100x1, avec un rapport de 100 (pour un bon raffinement au niveau de la paroi). Des simulations durant 10 secondes de temps physique ont été suffisantes dans notre cas pour atteindre un régime permanent :

 

 

 

 

On constate donc que le modèle RNGk-epsilon permet d'obtenir de bien meilleurs résultats que le modèle k-epsilon de base, sur tous les profils représentés ci-dessus. Concernant les profils de température, les résultats du modèle RNGk-epsilon obtenus sont en tout points bien plus proches des données expérimentales (par comparaison avec le modèle k-epsilon de base). Puis, pour les profils de vitesse, le maximum est mieux approché et l'estimation de la pente est meilleure.

Au final, le modèle RNGk-epsilon permet dans notre cas de mieux approcher quantitativement les données expérimentales de référence que pour tous les résultats obtenus jusqu'alors.

Par conséquent, toutes les simulations qui seront effectuées auront un modèle de turbulence RNGk-epsilon.

 

 

 

 

 

 

 

Etude de l'influence du maillage

Un autre paramètre qui s'avère très pertinent à analyser en CFD en général et pour notre cas en particulier, est l'effet du maillage. Pour cela, nous avons considéré deux maillages différents, un maillage grossier (250*50*1) avec un coefficient d'expansion suivant y de 10, et un autre raffiné (500*100*1) avec un coefficient de 100 suivant y. Les résultats obtenus, toujours en les comparant avec la référence expérimentale, sont affichés pour les différentes hauteurs 1.918m, 2.535m et 3.244m. Des simulations durant 10 secondes de temps physique ont été suffisantes dans notre cas pour atteindre un régime permanent. L'étude comparative de ces deux maillages, nous a donné les résultats suivants :

               

   

   

              

Nous remarquons que le maillage grossier donne de meilleurs résultats, ce qui est surprenant. Notre hypothèse pour expliquer cette remarque se base sur le coefficient d'expansion. En effet, comme nous prenons un ratio énorme (100) pour le maillage raffiné suivant y, donc en raffinant la zone proche de la paroi, les cellules deviennent trop étirées ce qui n'est pas agréable comme maillage.

Ce que nous pouvons tirer comme conclusion d'après cette analyse, et d'après d'autres manipulations que nous avons fait sur le maillage, est que Certes, OpenFOAM offre des outils de maillage (blockMesh, snappyHexMesh), cependant, ces outils ne sont pas assez puissants surtout pour des géométries complexes. La solution la plus pertinente pour ce problème du maillage est d'utiliser un autre logiciel pour générer le maillage comme Salome, ICEMCFD,...etc. et de l'exporter par le biais des outils offerts par OpenFOAM.

Etude de l'influence du paramètre epsilon

Nous avons noté que lorsque l'on calcule les grandeurs turbulentes, comme k (énergie cinétique turbulent) ou $\varepsilon$ (dissipation turbulente) et qu'on les injecte dans notre simulation, les résultats obtenus sont décevants.

Une étude sur l'influence du paramètre $\varepsilon$ est, au même titre que l'étude sur l'influence de k, indispensable pour mieux comprendre les phénomènes en jeu dans la simulation.

C'est pourquoi nous traçons, après plusieurs simulations, les profils de vitesse et de température pour différentes valeurs de $\varepsilon$. Le maillage utilisé contient 500x120x1 mailles, pour un rapport de 100 (pour le raffinement vers la paroi).

 

 

Tout d'abord, on remarque que les différences entre les différentes courbes pour les valeurs de $\varepsilon$ diminuent lorsque l'on considère des hauteurs de plus en plus élevées.
Cette constatation implique déjà une hypothèse qui semble se vérifier : la valeur de $\varepsilon$ imposée entrée est fixe, contrairement à celle à l'intérieur du domaine, qui se modifie au fur et à mesure des calculs effectués. Par conséquent, plus on se situe à une hauteur élevée, et moins l'influence de la dissipation "fixe" imposée en entrée se fait sentir, et le système peut alors évoluer vers une valeur de $\varepsilon$ qui fourni des résultats plus réalistes.

 

Ensuite, on remarque que $\varepsilon$ influe indéniablement sur les résultats obtenus, les simulations s'approchant le plus des données expérimentales étant pour les $\varepsilon$ les plus élevées. Cependant, la valeur de $\varepsilon$ calculée à partir des valeurs expérimentales est de l'ordre de ... 3.10-4 !! Ce qui est assez éloigné des tendances que l'on trouve ici ... Cela peut s'expliquer par le fait que les calculs sur les grandeurs turbulentes sont en réalité des approximations qui restent assez vagues, calculées à partir de grandeurs expérimentales qui peuvent se montrer imprécises. Ainsi, le $\varepsilon$ calculé ne serait pas très pertinent, puisqu'il s'agirait d'une approximation d'approximation.

 

Enfin, pour un $\varepsilon$ inférieur à 0.001, le schéma se met à diverger. Par conséquent, $\varepsilon$ joue également un rôle très important dans la stabilité du schéma numérique pour une simulation donnée, de trop petites valeurs de $\varepsilon$  étant bien entendu insuffisantes pour dissiper l'énergie qui s'accumule, et qui finalement résulte en une divergence, au niveau des vitesses le plus souvent pour notre cas (avec des vitesses supérieures à 7m/s et qui continuaient à augmenter alors qu'elles devraient être inférieures 1m/s).

 

 

 

Etude de l'influence du paramètre k

Dans une autre étude, nous avons analysé l'effet des valeurs de l'énergie cinétique turbulente k à l'entrée sur la qualité des résultats. Pour cela nous avons fait deux calculs, un avec un k non uniforme à l'entrée, calculé avec les grandeurs expérimentales tout en gardant les autres grandeurs turbulentes par défaut (valeurs qui étaient au début avant toute modification). L'autre calcul est fait avec un k uniforme à l'entrée, qui vaut la valeur moyenne du vecteur k du premier calcul. Comme pour les autres cas, les résultats obtenus, toujours en les comparant avec la référence expérimentale, sont affichés pour les différentes hauteurs 2.535m et 3.244m.

Nous obtenons les résultats suivants :

 

  

   

 

La même remarque est que la modification de cette valeur influence clairement les résultats. Il s'avère que le calcul à partir des relations pour l'estimation des grandeurs turbulentes (k,epsilon,...) est aberrant. Ceci peut se comprendre. En effet, l'estimation des grandeurs turbulentes est assez délicate pour les conditions aux limites est en général délicate. Le calcul avec les équations basées sur epsilon et k permet de donner juste un ordre de grandeur, surtout que la simulation est très sensible à ces grandeurs. En plus l'estimation de la dissipation pose toujours un problème pour les modèles type k-epsilon.

Calcul numérique le long du domaine (transition laminaire/turbulent)

Pour ne pas imposer un quelconque profil expérimental en entrée qui pourrait modifier l'écoulement, nous choisissons de réaliser un calcul dans le domaine en entier, c'est à dire de calculer la couche limite depuis le bord d'attaque, en passant par la zone de transition du régime laminaire vers le régime turbulent, jusqu'au bord de fuite (fin de la plaque).

Pour ce, nous procédons de deux façons:

a) Un seul calcul dans tout le domaine en considérant cette fois, un entrée libre.

b) Connaissant le point de transition laminaire/turbulent en x=0.8 m, nous effectuons deux calculs : Le premier va concerner la zone où la couche limite est laminaire, et ce en annulant la viscosité turbulente dans tout le domaine, ensuite nous passerons à un second calcul qui va concerner uniquement le domaine où la couche limite est turbulente, avec comme conditions en entrée les résultats en sortie du premier calcul. De cette façon, nous pourrons forcer la transition.

Mise en place des calculs

Calcul en un seul bloc

Le calcul se fera comme précédemment avec le solveur buoyantBoussinesqSimpleFoam, avec cette fois-ci une modification de la géométrie ( l'entrée ne commence plus à x=1.44m mais plutôt à 0). Le solveur potentialFoam n'est plus utilisé puisqu'il n'y a plus de problème de discontinuité des conditions de vitesses, et les conditions aux limites sont résumés dans le tableau ci-dessous :

  Entrée Plaque Sortie Bord
U (m/s) nonuniform List<vector>

fixedValue uniform (0 0 0)

zeroGradient zeroGradient
p (Pa) zeroGradient zeroGradient

fixedValue uniform

fixedValue uniform
T (K) nonuniform List<scalar>

fixedValue uniform 333.15K

zeroGradient zeroGradient

 

Calculs en deux blocs

Dans le premier domaine (de x=0 à x=0.8 m), nous lançons un premier calcul sous buoyantBoussinesqSimpleFoam avec cette fois-ci une viscosité turbulente nulle pour forcer le régime laminaire, et les conditions aux limites seront exactement identiques à celles utilisées précedemment.

Une fois le calcul convergé, nous récupérons les résultats au dernier pas de temps en x= 0.8m, pour ensuite les imposer comme conditions d'entrée pour le second domaine/calcul.

La récupération de ces profils en entrée peut se faire en passant d'abord par le logiciel "pararaview", pour ensuite enregistrer les datas sous format texte (data.dat), et enfin faire une des opérations de tri via quelques commandes linux :

  • Afin d'extraire les lignes contenant uniquement les données relatifs à la position x=0.8 et z=0.001

> grep -w 0.8 data.dat | grep -w 0.001  > Y.dat

  • Pour extraire les composantes des vitesses (colonnes 3, 4 et 5)

> cut -d',' -s -f3,4,5 Y.dat > U.dat

  • Pour extraire le profil de température (colonne 2)

> cut -d',' -s -f2 Y.dat > T.dat

  • Pour extraire le profil des pressions (colonne 1)

> cut -d',' -s -f1 Y.dat > p.dat

  • Pour respecter la forme avec laquelle s'écrit un profil de vitesses de type nonuniform List<vector>

> sed 's/^/(/' U.dat > U.dat (ouvrir une parenthèse au début de chaque ligne)

> sed 's/$/)/' U.dat > U.dat (fermer les parenthèses à la fin de chaque ligne)

> sed -e 's/,/ /g' U.dat > U.dat (remplacer le virgules par des espaces)

Après avoir récupérer les profils de vitesse, pression et température en sortie du premier bloc, on passe au calcul dans le deuxième bloc où les conditions en entrée seront de type nonuniform. Ainsi, il va falloir copier les dernier profils de vitesse, température et pression, lancer un premier calcul sous potentialFoam pour résoudre les problèmes de discontinuité, et ensuite réaliser un dernier calcul via buoyantBoussinesSimpleFoam.

 

 

 

 

Étude de la couche limite laminaire

Étude théorique

Dans cette partie, nous allons exploiter les simulations qui ont été faites sur le bloc en entier, en particulier la zone de couche laminaire, pour deux raisons. La première est de s'assurer que notre simulation est bien représentative de la réalité en comparant les résultats numériques à  la théorie, la deuxième raison est de s'assurer que les profils expérimentaux en entrée fournis sur le site d'ercoftac collent bien avec la simulation.

Tout d'abord, nous allons présenter les résultats théoriques concernant la partie laminaire.

Pour déterminer les profils de température et de vitesse théoriquement dans cette couche, nous allons nous baser bien évidemment sur les équations de Navier Stokes en couche limite, avec le modèle de Prandtl.

Ce modèle se base sur les mêmes hypothèses que nous avons mentionnées précédemment (voir http://hmf.enseeiht.fr/travaux/bei/beiep/content/g18/analyse-theorique-et-etude-preliminaire).

Nous obtenons donc les mêmes équations de conservation sauf le terme turbulent qui disparaît dans ce cas.

Conditions aux limites :

Vitesse :

$ \overrightarrow{U} (x,0)= \overrightarrow{0}$

$ u(x, \infty )=0 $

$ u(0,y)=0 $

 

Température :

T(x,0)=Tw ,

$ T(x,\infty)=Ta $

T(0,y)=Ta 

Donc finalement, notre problème est bien fermé.

Pour le résoudre, l'astuce est d'utiliser des variables de similitude qui permettent de passer des trois équations à dérivées partielles, à deux équations différentielles ordinaires.

 La variable de similitude adéquate pour ce cas est  : $ \eta (x,y)= (\frac {Gr_x} {4})^{1/4} \frac {y}{x} $

 Avec $ Gr_x=\frac{\beta g x^3 (T_w-T_a)}{\alpha^2} $.

Pour simplifier la résolution des équations, au lieu de considérer T, u et v , nous allons travailler avec les grandeurs suivantes :

$ \theta(x,y)=\theta(\eta)=\frac{T-T_\infty}{T_s-T_\infty} $

la fonction de courant $ \phi  $ telle que : $ u=\frac{\partial \phi}{\partial y}  $

 et $  v=\frac{\partial \phi}{\partial x}$

Nous pouvons écrire cette fonction de courant de la forme suivante : $ \phi=4 \nu \frac {Gr_x}{4}^{1/4}  \xi(\eta) $

Donc au lieu de travailler avec des EDP dont les inconnues sont u, v et T, nous allons considérer des EDO dont les inconnues sont $\theta$ et $\phi$ qui ne dépendent que de $\eta$.

Les équations ordinaires à résoudre sont :

 $\frac {d^3 \xi}{d \eta^3}+3 \xi \frac {d^2 \xi}{d \eta^2}-2 (\frac {d \xi}{d \eta})^2+ \theta=0 $

$ \frac {d^2 \theta}{d \eta^2}+3 Pr \xi (\frac {d \theta}{d \eta})=0 $

Pour les conditions aux limites, de la même façon, il faut les écrire en fonctions des nouvelles variables $ \xi $, $ \theta $ et $ \eta $.

Nous avons donc affaire à deux équations différentielles ordinaires (non-linéaires), avec les conditions aux limites qu'il faut, nous pouvons les résoudre numériquement facilement (avec matlab par exemple)..

A partir de cette résolution, nous pouvons accéder à des paramètres importants comme le nombre de Nusselt, l'épaisseur de la couche limite, la vitesse maximale en fonction de x, ..etc.

Le nombre de Nusselt :

Par définition du nombre de Nusselt : $ Nu= - \frac {\frac {\partial T}{\partial y} x }{Tw-Ta}$

Ce qui donne après calcul :  $ Nu= (\frac {Gr_x}{4})^{0.25} g(Pr).$

Avec $g(Pr)$=$ \frac {0.75 Pr^{0.5}}{(0.609+1.221 Pr^{0.5}+1.238 Pr)^{1/4}}$

L'épaisseur de la couche limite :

A partir de la définition de cette grandeur, on peut déduire facilement que cette grandeur varie en $ x^{1/4} $ : 

$ \delta (x) = x (\frac{Gr_x}{4})^{0.25}$

La vitesse maximale :

Une autre grandeur intéressante est la vitesse maximale Umax.

Théoriquement, on trouve que $ Umax \approx 0.5 \sqrt{g \beta (Tw-Ta) x} $

Exploitation des résultats & Comparaison

A présent nous avons les résultats théoriques ainsi que ceux de simulation. Un dernier point à préciser est que pour les différentes grandeurs que nous allons comparer, nous n'avons pas accès directement par Parafoam. Pour chaque grandeur, il y en a des manipulations à a faire.

Le nombre de Nusselt :

Numériquement, nous avons les profils de température en tout point, pour calculer le nusselt, il suffit de calculer le gradient de température au niveau de la paroi. Pour cela, nous avons calculé la différence entre la température de la paroi et celle de la maille qui suit suivant la direction y. Pour que le calcul soit correct, il faut avoir des mailles suffisamment fines.

Remarque Pour tout calcul sur Parafoam, il ne faut surtout pas exporter les résultats pour des lignes données utilisant plotoverline, car ceci ne permet d'avoir que des valeurs pour un pas d'espace de 0.005 quelque soit le maillage, l'une des faiblesses de cet outil. Pour surmonter cette difficulté, il faut exporter les résultats de tout le domaine, et après faire un tri sur les zones qui intéressent l'utilisateur.

La comparaison des deux approches donne :

                                 

Nous remarquons que les deux profils ne collent pas du tout, quelque soit le maillage. L'origine de cet écart ne provient pas de la simulation ni du maillage, car nous avons bien vérifié que la simulation est correcte, les profils expérimentaux à l'entrée de la couche limite turbulente collent bien avec les profils à la sortie du premier bloc. Le problème vient plutôt de la définition du gradient de température que nous avons considéré pour calculer le Nusselt numériquement. En effet, théoriquement, on montre que le Nusselt augmente avec x, ce qui est bien physique. Cependant, Si pour notre définition du gradient, comme la température suivant x augmente avec x, donc le gradient diminue forcément, par suite Le Nusselt diminue avec x. Nous avons beau cherché pour résoudre ce problème, mais malheureusement nous nous sommes pas arrivés à le résoudre. Les idées que nous avons eu pour surmonter cette difficulté étaient de chercher si OpenFOAM permet de calculer automatiquement ces grandeurs, en les codant par exemple (comment ce qu'on peut faire pour les coefficients de portance et de traînée). L'autre idée était de se servir du Python pour les coder, car ce langage s'avère très puissant pour l'automatisation des calculs et l'obtention des résultats. Malheureusement, nous n'avons pas eu le temps pour faire ces manipulations.

Vitesse maximale :

Pour cette grandeur, le calcul est moins délicat. La comparaison des deux approches nous donne :

 

 

                                      

 

Nous constatons que les deux profils ont la même forme avec un "léger" écart.

Epaisseur de la couche limite dynamique :

Concernant cette grandeur, c'était la galère pour la déterminer numériquement. En effet, si nous faisons un plotoverline pour tous les points du maillage, le calcul de cette épaisseur est impossible avec Parafoam, vu que cet outil considère des pas d'espace de 0.005m et non pas les points du maillage, ce qui est quasiment pas faisable, puisque cette épaisseur est de l'ordre du millimètre. Nous avons essayé d'exporter les résultats de tout le domaine, cependant, vu le nombre de points du maillage, et les vitesses qui étaient très sensibles, le calcul de cette grandeur était imprécis.

Exploitation des résultats

Un bloc

Un premier calcul basé sur des grandeurs turbulentes mises en place par défaut (cas test hotroom) nous permet d'obtenir les courbes ci-dessous :

Nous constatons que les profils numériques sont plus ou moins satisfaisants puisqu'ils s'approchent des profils expérimentaux, surtout en x = 2.535 m, où non seulement la simulation numérique prévoit la pente de décroissance mais également  le maximum de vitesse.


Un second calcul avec cette fois-ci des valeurs pour les grandeurs turbulentes calculées à partir des données expérimentales, donne les résultats ci-dessous :

 

Le tracé des courbes de vitesse et température pour cette deuxième simulation permet d'abord de confirmer la sensibilité du calcul aux grandeurs turbulentes, ainsi que de remarquer la non-amélioration des résultats, contrairement à ce que nous pourrions nous attendre.

Cette remarque pourrait être justifiée par la manière dont le calcul des grandeurs turbulentes s'est effectué ou imposé dans le domaine de calcul. En effet, le fait d'imposer une valeur moyenne dans tout le domaine ne peut être physiquement correcte surtout au niveau de l'entrée, d'ailleurs  cette hypothèse peut être confirmée par l'amélioration observée des profils quand on s'éloigne de l'entrée.

Deux blocs

 

La dernière configuration de calcul, à savoir la simulation numérique en deux blocs permet d'obtenir les profils ci-dessous :

Nous constatons que les profils numériques sont d'autant plus satisfaisants que ceux obtenus pour un calcul en un seul bloc, ce qui est parfaitement cohérent avec la théorie/expériences de la transition de la couche limite laminaire vers la couche limite turbulente en x = 0.8 m. 

Le remarque faite précédemment sur l'influence des valeurs des grandeurs turbulentes est revérifiée.

Raffinement du maillage

Afin d'étudier l'influence du maillage sur la précision des résultats du calcul en un seul bloc, nous avons considéré deux maillages différents, un maillage grossier (500*50*1) avec un coefficient d'expansion suivant y de 10, et un autre raffiné (1000*50*1) avec un coefficient de 20 suivant y. Les résultats obtenus, toujours en les comparant avec la référence expérimentale, sont affichés ci-dessous pour les différentes hauteurs 1.438m, 1.918m, 2.535m et 3.244m :

Nous remarquons que les courbes obtenus avec le maillage grossier sont légèrement plus proches des valeurs expérimentales , ce qui est surprenant.  Comme pour le calcul ERCOFTAC, l'hypothèse pour expliquer cette remarque  pourrait se baser sur le coefficient d'expansion. En effet, le raffinement en proche paroi a pour effet d'étirer les cellules de gauches, ce qui pourrait induire des erreurs de calculs.

 

Comparaison

 

Enfin nous comparons les différentes simulations mises en place pour ce calcul le long de la plaque en traçant comme précédemment les profils de vitesse et de température aux niveaux des quatre positions de mesures expérimentales: x=1.438m, x=1.918m, x=2.535m et x=3.244m.

Remarque : La courbe en rouge correspond aux résultats d'un calcul en deux blocs avec pour manière d'établir l'écoulement laminaire en bas du domaine, la désactivation de la turbulence (turbulence OFF) dans le fichier transportpropeties.

La comparaison des différentes simulations à partir des profils de vitesse/température permet de valider le calcul en deux bloc. Cette méthode permet donc de d'obtenir les résultats les plus proches de la réalité et s'avère la plus logique puisqu'elle permet de prendre en compte la zone de transition, ce qui n'est pas le cas du calcul en "un bloc". Le seul inconvénient de cette méthode s'avère être le positionnement de la zone de transition!

Conclusion

 

 

Ainsi, ce projet nous a permis de découvrir un nouvel outil de simulation numérique, qui occupe de plus en plus d'importance auprès de nombreux industriels désireux de travailler avec des codes open-source fonctionnels.

Une partie assez longue de ce projet a été consacrée à trouver la bonne configuration numérique, pour les divers paramètres et les conditions limites pour s'assurer d'obtenir une simulation au moins qualitativement bonne. Sur cette base, un travail tourné vers des vérifications quantitatives a pu être mené, et l'influence de divers paramètres numériques et géométriques a pu être testé. Enfin, un peu de recul par rapport au cas étudié a été pris, la plaque entière a été considérée et des études théoriques ont été réalisées. 

Finalement, les résultats quantitatifs obtenu sont prometteurs, mais malheureusement, la complexité d'OpenFOAM en fait un outil très difficile à utiliser et à comprendre entièrement. Même après plusieurs mois de manipulations, des erreurs dans nos simulations étaient découvertes et corrigées si cela était toutefois possible.

Il revient désormais à nos partenaires industriels de savoir si ce qui est gagné en téléchargeant des codes open-sources permet bien de compenser le temps inévitablement perdu pour l'établissement de chacune des simulations numériques.

Néanmoins, outre le fait de laisser derrière nous une base d'utilisation pratique d'OpenFOAM, le travail en lui-même n'est pas exactement fini. Concernant notre cas, des détails restent toujours à approfondir : les modifications parasites imposées par le solveur potentialFoam, les problèmes de stabilité du schéma numérique avec l'ordre de grandeur de la dissipation turbulente obtenue,  etc.... De plus, le sujet reste "Validation du solveur OpenFOAM pour la résolution de problèmes thermiques". Pour répondre convenablement à ce sujet, il convient également d'étudier des cas de figure supplémentaires autres que la convection naturelle, comme des problèmes de convection forcé, conduction ou convection et conduction à la fois ...

 

 

 

 

 

 

Références

 

Références sur Internet :

 

        Et plus précisément :  http://www.openfoam.org/archive/2.1.0/docs/user/

 

 

 

  

 

Références bibliographiques :

 

 

 

Remerciements

 

Nous souhaitons vivement remercier Mr LEGENDRE Dominique, dont les réunions et conseils nous ont permis de prendre un recul indispensable pour mener à bien notre projet de manière efficace.

 

Nous remercions également Mme PEDRONO  Annaig qui nous a apporté une grande aide, qui était bien nécessaire pour mieux cerner le logiciel OpenFOAM et pour mener à bien nos simulations.

 

Aussi, nous voudrions remercier Mr NEAU Hervé, dont l'expertise nous a permis de remettre en question nos modèles erronés.

 

 

Enfin, nous remercions également nos partenaires d'ALTRAN, qui nous ont non seulement permis de découvrir un nouveau logiciel, mais qui nous ont également apporté une manière de voir les choses qui nous a permis de dépasser le simple sujet du projet.