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.