OpenFOAM

OpenFOAM (Open Field Operational and Manipulation) est un logiciel de simulation multi-physiques qui résout principalement les équations différentielles de la mécanique des fluides en utilisant la méthode des volumes finis.

OpenFOAM est essentiellement constitué d'une bibliothèque logicielle en langage C++ libre. Le code de OpenFOAM est très intéressant lorsqu'il s'agit d'implémenter de nouveaux modèles. Aucune connaissance approfondie du C++ n'est nécessaire pour écrire son propre modèle sur OpenFOAM.

 

 

Génération ce maillage

OpenFOAM propose deux outils pour générer des maillages : blockMesh et snappyHexMesh. Notre BEI n'a pas pour but de se focaliser sur la manipulation de maillage. Par conséquent nous ne développons pas cette partie dans ce projet.
Pour plus d'information sur l'utilisation de ces deux outils, rendez-vous sur l'URL suivante.

http://hmf.enseeiht.fr/travaux/bei/beiep/content/g21/2-creation-maillage
http://hmf.enseeiht.fr/travaux/projnum/content/utilisation-basique-de-snappyhexmesh
 

Il est important de noter que OpenFOAM est capable de convertir un certain nombre de maillages développé par d'autres logiciels comme DesignModeler, Salome ou CFX. OpenFOAM dispose de plusieurs d'outils spécifiques à chaque mailleur pour convertir les maillages en extension lisible par les solvers OpenFOAM. On peut citer entre autre l'outil fluent3DMeshToFoam pour convertir les .msh et l'outil star4ToFoam pour convertir les maillages Star-CD. La liste des convertisseur est disponible sur l'URL suivante.

http://www.openfoam.org/docs/user/standard-utilities.php

 

 

Calcul avec des solveurs

Comme annonce dans la présentation du BEI, il existe de nombreux solveurs sur OpenFOAM qui couvrent une large gamme de domaines de la physique (combustion, écoulements incompressibles, compressibles, turbulents, multiphasiques, avec ou sans réaction chimique, transferts thermiques etc). Pour les écoulements turbulents, il existe de différents modèles implantés dans le code OpenFOAM comme RANS (k-epsilon, k-omega), LES et DNS. Pour une liste complète, nous vous envoyons une nouvelle fois sur le site OpenFOAM qui regorge d'information utiles.

http://www.openfoam.org/features/standard-solvers.php
http://www.openfoam.org/features/turbulence.php

 

 

Post-traitement

OpenFOAM est distribué avec Paraview, un logiciel de post-traitement open-source. Pour les utilisateurs qui préfèrent d'autres outils de visualisation, il existe des modules d'export pour Fluent, Ensight, FieldView. Là encore, on trouve la liste de ces modules sur le site officiel de OpenFOAM dans la rubrique standard utilities.

http://www.openfoam.org/docs/user/standard-utilities.php

 

Pour ce qui concerne le fonctionnement des répertoires et dictionnaires de OpenFOAM, nous ne détaillerons pas leur principe d'utilisation. En revanche, pour ce qui concerne notre projet, nous expliquerons les choix effectués dans nos démarches. Pour comprendre comment OpenFOAM fonctionne, un excellent tutoriel ce trouve sur l'URL suivante.

https://www.imft.fr/IMG/pdf/INITIATION_OPENFOAM_TOME_1v3-05.pdf

 

 

Intérêt de OpenFOAM

Le code OpenFOAM est un logiciel open-source et il peut être téléchargé gratuitement depuis le site officiel. Comme c'est un logiciel open-source, l'utilisation de ce logiciel est beaucoup plus souple par rapport aux autres logiciels commerciaux et tout le monde a l'accès directement au code pour pouvoir créer son propre solveur.

Voici un example d'équation différentielle :

$\frac{\partial {\rho U}}{\partial t}+\nabla . {\phi U} - \nabla . {\mu \nabla U}=-\nabla p $

Cette équation est écrit comme ci-dessous dans le code OpenFOAM :

solve

(

        fvm::ddt(rho, U)

     + fvm::div(phi, U)

     -  fvm::laplacian(mu, U)

        ==

     -  fvc::grad(p)

);

On peut remarquer que OpenFOAM est logiciel intéressant dans son utilisation pour plusieurs points :

 

 

 

Présentation du problème sur OpenFOAM

Après avoir établi une nomenclature des cuves agitées et développé les méthodes de post traitement, l'objectif est de comparer les différentes stratégies de simulation d'un système agité (cuve agitée) pour un régime turbulent avec le code OpenFOAM. Souvent, on utilise l'une des trois stratégies suivantes. L'approche à référentiel Simple (Simple Reference Frame/SRF), l'approche à référentiels multiples (Multiple Reference Frame/MRF) et l'approche maillage glissant (Moving Mesh).

 

 

Simple Reference Frame

On associe le système agité à un seul référentiel tournant avec la vitesse de rotation du rotor. Dans ce cas, les équations dans le référentiel tournant sont résolues pour tout le domaine avec la force de Coriolis.

 

 

Multiple Reference Frame

Dans cette approche, le domaine est divisé en deux parties. Une partie autour de l'agitateur est simulée dans un repère tournant avec l'agitateur (un référentiel tournant) et les équations sont résolues avec un terme en plus : le terme de Coriolis. Pour le reste du domaine (la deuxième partie), les équations sont résolues en repère fixe.

image

L'approche MRF ne tient pas compte du mouvement relatif  d'une zone mobiles par rapport à des zones adjacentes (qui peuvent être mobiles ou stationnaires), le maillage reste immobile pour le calcul. Cela est analogue à la congélation du mouvement de la partie mobile dans une position spécifique et on observe le champ de l'écoulement instantané autour le rotor à cette position.  On appelle cette aussi cette méthode la méthode du frozen rotor ou agitateur gelé.

Cette approche est approximative mais elle a l'avantage de mettre en jeu des calculs stationnaires (le maillage est immobile) et donc plus rapide.

 

 

Moving Mesh

La méthode de simulation la plus exacte consiste à utiliser le moving mesh. Pour le moving mesh, le maillage est construit de la même façon que pour MRF, mais les équations sont résolues en instationnaire. A chaque pas de temps, le maillage de la partie centrale tourne avec le rotor et l'interface entre les deux zones est recalculé. Pour obtenir des résultats fiables, il ne faut pas que la rotation de l'agitateur(et donc du maillage de la partie centrale) dépasse 5 degrés par pas de temps.

Image : OpenFOAM Project : Different ways to treat rotating geometries par Olivier Petit

Ici, on voit bien que le maillage du référentiel tournant tourne en fonction de temps.

 

 

Les géométries de la cuve

Pour ce projet, TECH-AM Ing met à disposition ses maillages de cuves agitées. Comme annoncé précédemment, les objectifs de se BEI sont de comparer les approches numériques avec le post traitement développé et non pas de concevoir les géométries et maillages.

Voici les géométries fournies par TECH-AM Ing pour le projet.

 

 

Cas Test 3D

Voici la géométrie (coupe intérieure) de la cuve agitée sur laquelle nous allons mettre en place les post traitements. Sur paraview, on peut aller dans la rubrique properties et cocher Patch Names pour afficher les noms de différents patch.

La cuve est constituée de quatre parties (que l'on appelle patch sur OpenFOAM) :

  • la pale qui tourne au centre de la cuve avec une certaine vitesse de rotation (définie par le nom helice dans le maillage)
  • le contour extérieur limitant la cuve (défini par le nom pourtour_externe dans le maillage)
  • le disque haut de la cuve ; on ne le voit pas sur cette image (défini par le nom disque_haut dans le maillage)
  • le disque bas de la cuve (défini par le nom disque_bas dans le maillage).

Il faut bien connaître les différents patches prédéfinis dans le maillage pour qu'on puisse bien définir les conditions aux limites sur OpenFOAM.

 

 

Cas de la géométrie réel :

Voici les géométries avec les patches en configuration MRF.

Voici la géométrie (coupe intérieure) de la cuve agitée.

La cuve est constituée de deux parties principales :

  • La zone_mrf (le cylindre de la taille plus petite que la cuve) contient Wall_fond_zone_mrf, agitateur, agitateur:011 et Wall_arbre_zone_mrf. Wall_fond_zone_mrf, agitateur, agitateur:011 et Wall_arbre_zone_mrf font partie de la pale qui tourne au centre de la cuve avec une certaine vitesse de rotation.
  • La zone_fluide est le reste de la cuve sauf la zone_mrf qui contient quatre composantes de la géométrie : Wall_fond_cuve, wall_arbre_cuve, Wall_virole, et surface_libre (qu'on ne le voit pas sur la géométrie ci-dessus). Wall_fond_cuve, wall_arbre_cuve et Wall_virole font partie de la cuve agitée et surface_libre représente la surface libre du fluide dans la cuve agitée.

Solveurs Choisis

Il existe différents solveurs prêts à être utilisé sur OpenFOAM.  Listons quelques solveurs pour un écoulement incompressible :

  • icoFoam : les écoulements incompressibles laminaires (instationnaires) pour des fluides Newtoniens
  • nonNewtonianIcoFoam : les écoulements incompressibles laminaires (instationnaires) pour des fluides non-Newtoniens/Newtoniens
  • simpleFoam : les écoulements incompressibles turbulents (stationnaires)
  • SFRSimpleFoam : les écoulements incompressibles turbulents (stationnaires) pour des fluides non-Newtoniens/Newtoniens dans un seul référentiel tournant
  • MRFSimpleFoam : les écoulements incompressibles turbulents (stationnaires) pour des fluides non-Newtoniens/Newtoniens en référentiels multiples (souvent un référentiel tournant : le rotor et le fluide environnant, un référentiel immobile : le fluide près de la paroi)
  • pimpleDyMFoam : écoulements incompressibles (instationnaire) pour des fluides Newtoniens en maillage glissant (moving mesh).

( cf  :  http://www.openfoam.org/features/standard-solvers.php pour les solveurs standards sur OpenFOAM.

Pour notre BEI, on utilise trois solveurs : SRFSimpleFoam, MRFSimpleFoam et pimpleDyMFoam. Le MRFSimpleFoam sera le plus utilisé pour les démarches à suivre.

Prise en main sur OpenFOAM

Dans cette partie, nous avons détailler comment sont définis les conditions aux limites et les conditions initiales pour pouvoir faire le calcul numérique à partir du maillage fourni par TECH-AM Ing.

Avant de passer dans un cas de simulation, voici quelques explications sur le fonctionnement du code OpenFOAM. Comme introduit dans les parties précédentes, il existe une multitude de solveurs dans OpenFOAM. On choisi le cas qui nous intéresse  et on le copie sur notre propre espace de travail personnel afin de pouvoir le modifier. Ce système de fichier contient initialement au moins trois dossiers : 0, constant et system.

Image : http://hmf.enseeiht.fr/travaux/bei/beiep/content/g18/structure-generale-...

Le dossier 0 contient toutes les informations sur les grandeurs à l'état initial. Il faut définir les conditions aux limites et initiale pour les différents patches en se basant sur le tutoriel. Pour prendre connaissance des différents types de conditions aux limites, beaucoup d'information se trouvent sur l'URL suivante.

http://www.openfoam.org/docs/user/boundaries.php

 

Le dossier constant contient au moins trois fichiers (transportProperties, turbulenceProperties et RASProperties) dans lesquelles on définit les propriétés du fluide, le modèle de turbulence utilisé ainsi que les paramètres du modèle de turbulence et un sous-dossier qui, lui-même, contient les éléments nécessaires à la description du maillage.

Le dossier system contient au moins trois fichiers que sont controlDict, fvSchemes et fvSolution. Dans le fichier controlDict, on a accès aux paramètres temporels comme le pas de temps et la fréquence d'enregistrement de calcul. Le fichier fvSchemes nous permet de choisir les schémas numériques de discrétisation des équations aux dérivées partielles. Le fichier fvSolution nous permet de préciser les critères de convergences pour les différentes grandeurs. L'URL suivante propose une description plus en détail de l'utilité de ces fichiers.

http://hmf.enseeiht.fr/travaux/bei/beiep/content/g18/description-fichiers

 

Les sous parties suivantes exhibent les configurations que nous avons utilisé pour les deux géométrie dans le cas MRF.

Cas Test 3D

Pour le Cas Test 3D, le modèle k-epsilon est choisi comme modèle de fermeture pour résoudre l'équation de Navier-Stokes moyennée. A noter que le modèle k-Epsilon n'est pas adapté à notre situation puisqu'il est utilisé pour des écoulements parallèles pleinement turbulent (typiquement un écoulement en conduite). Néanmoins, pour disposer de vitesses de convergence rapide il sera choisi. Préférez le Reynolds Stress Model ou le k-omega SST pour l'obtention de résultats plus cohérents.

La suite est destinée à l'explicitation des divers fichiers à paramètrer pour lancer la simulation.

 

 

Turbulent-Stationnaire

0

Puisque nous choisissons de simuler un écoulement turbulent, il est nécessaire de définir les conditions aux limites pour trois grandeurs en plus de la pression et de la vitesse. Il s'agit de la viscosité turbulente, du taux de dissipation visqueux et de l'énergie cinétique turbulente.

 

 

P

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    location    "0";
    object       p;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
dimensions             [0 2 -2 0 0 0 0]        // attention, P est normalisé par la densité du fluide

internalField           uniform 0;        // le champ de pression relatif intérieur est nul

boundaryField
{
     disque_haut
     {
          type                      zeroGradient;        //pas de gradient normal pour toutes les grandeurs
      }
     pourtour_externe
     {
          type                      zeroGradient;    
      }
     disque_externe
     {
          type                      zeroGradient;    
      }
     helice                              
     {                                     
          type                      zeroGradient;
      }
}
 

/ / ******************************************************************************** / /

 

 

U

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    location    "0";
    object       U;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
dimensions                  [0 1 -1 0 0 0 0]

internalField                uniform (0 0 0);       // le champ de vitesse intérieur est nul

boundaryField
{
     disque_haut
     {
          type                      fixedValue;    
          value                    uniform (0 0 0);
      }
     pourtour_externe
     {
          type                      fixedValue;    
          value                    uniform (0 0 0);
      }
     disque_externe
     {
          type                      fixedValue;    
          value                    uniform (0 0 0);
      }
     helice                        // le vecteur vitesse est nul sur disque_haut, pourtour_externe,
     {                               // disque_bas et helice, on considère la condition de non glissement
          type                      fixedValue;    
          value                    uniform (0 0 0);
      }
}
 

/ / ******************************************************************************** / /

 

 

Les trois grandeurs supplémentaires à configurer.

 

nut

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    location    "0";
    object       nut;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
dimensions                   [0 2 -1 0 0 0 0]

internalField                 uniform 0;      

boundaryField
{
     disque_haut
     {
          type                      nutkWallFunction;       //traitement de la viscosité à la paroi
          value                    uniform 0;
      }
     pourtour_externe
     {
          type                      nutkWallFunction;    
          value                    uniform 0;
      }
     disque_externe
     {
          type                      nutkWallFunction;    
          value                    uniform 0;
      }
     helice             
     {                              
          type                      nutkWallFunction;    
          value                    uniform 0;
      }
}
/ / ******************************************************************************** / /

 

 

k

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    location    "0";
    object       k;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
dimensions               [0 2 -2 0 0 0 0]

internalField             uniform 1;      

boundaryField
{
     disque_haut
     {
          type                      kqWallFunction;    
          value                    uniform 0;
      }
     pourtour_externe
     {
          type                      kqWallFunction;    
          value                    uniform 0;
      }
     disque_externe
     {
          type                      kqWallFunction;    
          value                    uniform 0;
      }
     helice                  
     {                                   
          type                      kqWallFunction;    
          value                    uniform 0;
      }
}
 

/ / ******************************************************************************** / /

 

 

epsilon

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    location    "0";
    object       epsilon;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /
dimensions                     [0 2 -3 0 0 0 0]

internalField                   uniform 20;      

boundaryField
{
     disque_haut
     {
          type                      epsilonWallFunction;    
          value                    uniform 0;
      }
     pourtour_externe
     {
          type                      epsilonWallFunction;    
          value                    uniform 0;
      }
     disque_externe
     {
          type                      epsilonWallFunction;    
          value                    uniform 0;
      }
     helice                         
     {                                 
          type                      epsilonWallFunction;    
          value                    uniform 0;
      }
}
 

/ / ******************************************************************************** / /

 

 

Constant

 

RASProperties

Comme expliqué dans la partie précédente : on modifie le fichier RASProperties pour activer le modèle de k-epsilon comme ci-dessous :

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    location    "constant";
    object      RASProperties;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /

RASModel         kEpsilon;      // Le modèle de fermeture utilisé est k-epsilon

turbulence          on;                // L'option turbulent est activée

printCoeffs          on;              // Affichage des coefficients de turbulence dans le shell
 

/ / ******************************************************************************** / /

Pour plus d'information sur les modèles de turbulence disponibles dans les librairies OpenFOAM, voir le site à l'URL suivante : http://www.openfoam.org/features/RAS.php

 

 

transportProperties

C'est dans ce fichier qu'est paramétré les propriétés du fluide présent dans la cuve, pour nous il sera newtonien avec une viscosité cinémétique de 1e-5 m²/s.

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version       2.0;
    format         ascii;
    class          dictionary;
    location     "constant";
    object         transportProperties;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /

transportModel     Newtonian;

nu                           nu [ 0 2 -1 0 0 0 0  ] 1e-5;  // La viscosité cinématique de fluide ( $ m^2 s^{-1} $)

 

/ / ******************************************************************************** / /

 

 

MRFZones

C'est dans ce fichier qu'est spécifiée la zone tournante MRF. La zone tournante est, comme son nom l'indique une zone. Elle doit être définie dans /constant/polyMesh/cellZones.

 

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version       2.0;
    format         ascii;
    class          dictionary;
    location     "constant";
    object         MRFZones;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /

1
(
     zone_mrf
     {
          
/ / Fixed patches (by default they 'move' with the MRF zone)

          nonRotatingPatches ();
          origin      origin      [0 1 0 0 0 0 0 ]    (0 0 0);     // Le centre de la cuve tournante
          axis         axis        [0 0 0 0 0 0 0 ]    (0 0 1);     // L'axe de rotation : ici, la rotation se fait selon l'axe  Z
          omega    omega   [0 0 -1 0 0 0 0 ]   40;           // la vitesse de rotation de la pale en radians par seconde
!!
     }

)
/ / ******************************************************************************** / /

 

 

 

System

 

fvSchemes

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version       2.0;
    format         ascii;
    class          dictionary;
    location     "system";
    object         fvSchemes;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /

ddtSchemes
{
    default         steadyState;        // pour le régime stationnaire
}

gradSchemes                             // les schémas de discrétisation des différents termes dans les équations
{
    default         Gauss linear;
    grad(p)         Gauss linear;
    grad(U)         Gauss linear;
}

divSchemes
{
    default         none;
    div(phi,U)      Gauss limitedLinearV 1;
    div(phi,k)      Gauss limitedLinear 1;
    div(phi,epsilon) Gauss limitedLinear 1;
    div((nuEff*dev(T(grad(U))))) Gauss linear;
}

laplacianSchemes
{
    default         none;
    laplacian(nuEff,U) Gauss linear corrected;
    laplacian((1|A(U)),p) Gauss linear corrected;
    laplacian(DkEff,k) Gauss linear corrected;
    laplacian(DepsilonEff,epsilon) Gauss linear corrected;
}

interpolationSchemes
{
    default         linear;
    interpolate(U)  linear;
}

snGradSchemes
{
    default         corrected;
}

fluxRequired
{
    default         no;
    p               ;
}

/ / ******************************************************************************** / /

 

 

fvSolution

/*--------------------------------*- C++ -*--------------------------------------------------------*\
| ======                        |                                                                                       
| \\         /  F ield             | OpenFOAM:   The Open Source CFD Toolbox     
|  \\      /   O peration      | Version:          2.1.0                                                   
|   \\   /    A nd                 | Web:                www.OpenFOAM.org                       
|    \\/     M anipulation  |                                                                                       
\*----------------------------------------------------------------------------------------------------*/
FoamFile
{
    version       2.0;
    format         ascii;
    class          dictionary;
    location     "system";
    object         fvSolution;

/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / /

solvers
{
    p
    {
        solver          GAMG;
        tolerance       1e-08;
        relTol          0.001;
        smoother        GaussSeidel;
        cacheAgglomeration true;
        nCellsInCoarsestLevel 20;
        agglomerator    faceAreaPair;
        mergeLevels     1;
    }

    U
    {
        solver          smoothSolver;
        smoother        GaussSeidel;
        nSweeps         5;
        tolerance       1e-07;                      //valeur sous laquelle le solveur doit descendre dans la convergence
                                                                //
des calculs   res < tolerance
        relTol          0.001;                        //ou alors,  relTol < residu_initial
    }                                                         // la première condition atteinte stoppe la simulation

    k
    {
        solver          smoothSolver;
        smoother        GaussSeidel;
        nSweeps         10;
        tolerance       1e-07;
        relTol          0.001;
    }

    epsilon
    {
        solver          smoothSolver;
        smoother        GaussSeidel;
        nSweeps         10;
        tolerance       1e-07;
        relTol          0.001;
    }
}

SIMPLE
{
    nNonOrthogonalCorrectors 5;     // Quand les centres de cellules sont pas alignés, cela permet de corriger les
    pRefCell        0;                              // gradients
    pRefValue       0;
}

relaxationFactors
{
    fields
    {
        p               0.3;
    }
    equations
    {
        U               0.3;
        k               0.1;
        epsilon         0.1;
    }
}

/ / ******************************************************************************** / /

 

 

Turbulent-Instationnaire

Pour faire la même simulation mais instationnaire, il faut modifer le schéma de discrétisation du terme dt dans le fichier fvSchemes :

ddtSchemes
{
    default         Euler;
}

 

 

Laminaire-Stationnaire

Pour faire une simulation pour un très petit nombre de Reynolds (on est dans un régime laminaire), il faut modifier le fichier RASProperties comme ci-dessous :

// RASModel         kEpsilon;  
RASModel           laminar     

turbulence          off;                // L'option turbulent est déactivée car on est dans le régime laminaire

printCoeffs          off;             

 

Pour les conditions aux limites et conditions initiales, il suffit juste de définir les deux paramètres de $ P $ et $ U $ .

 

 

 

Cas réel 3D (une hélice)

Pour le cas Réel 3D, les paramètres sont exactement les mêmes que pour le cas Test 3D. Seul change la condition sur la partie supérieure.

  • agitateur
  • wall_virole
  • wall_fond_cuve
  • wall_fond_mrf
  • wall_arbre_zone_mrf
  • wall_arbre_cuve
  • agitateur:011
  • surface_libre

Tous les patches dans le cas Test 3D (disque_haut, pourtour_externe, disque_bas et helice) sont les murs. Reprenons notre cas Réel 3D : tous les patches sauf surface_libre sont les murs et on peut faire pareil que la partie précédente pour définir les conditions aux limites et conditions initiales dans les fichier p , U, epsilon, k et nut. Par contre, on définit le patch de surface_libre dans les fichiers p , U, epsilon, k et nut comme suivant :

    surface_libre
    {
        type            symmetryPlane;
    }

 

Pour pouvoir lancer le cas Réel 3D, on reprend les démarches expliquées dans le cas Test 3D.