Steady-state simulation of Ahmed body Part 2 of 3 (Calculation setup)

The computational grid is presented in the Part 1.

Solver: simpleFoam
Wind speed: 60m/s
Turbulent intensity at inlet: 0.5%
Turbulence model: realizableKE
Div scheme: Gamma NVD scheme

controlDict:

application     simpleFoam;
startFrom       latestTime;
startTime       0;
stopAt          endTime;
endTime         10000;
deltaT          1;
writeControl    adjustableRunTime;
writeInterval   100;
purgeWrite      0;
writeFormat     ascii;
writePrecision  7;
writeCompression off;
timeFormat      general;
timePrecision   6;
runTimeModifiable true;

functions
{
  fieldMinMax
  {
    type               fieldMinMax;
    functionObjectLibs ("libfieldFunctionObjects.so");
    enabled            true;
    outputControl      timeStep;
    outputInterval     1;
    log                true;
    mode               magnitude;
    fields
    (
      U p
    );
  }

  forces
  {
      type                forces;
      functionObjectLibs  ("libforces.so");
      outputControl       timeStep;
      outputInterval      1;
     
      patches             ("ahmed.*");
      pName               p;
      UName               U;
      rhoName             rhoInf;
      log                 true;
     
      CofR                (0 0 0);
     
      rhoInf              1.225;
  }
}

fvSchemes:

ddtSchemes
{
    default         steadyState;
}

gradSchemes
{
    default         cellLimited Gauss linear 0.333;
}

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

laplacianSchemes
{
    default         Gauss linear limited 0.333;
}

interpolationSchemes
{
    default         linear;
}

snGradSchemes
{
    default         limited 0.333;
}

fluxRequired
{
    default         no;
    p               ;
}

fvSolution:

solvers
{
    "p.*"
    {
        solver          GAMG;
        tolerance       1e-8;
        relTol          0;
        smoother        GaussSeidel;
        nPreSweeps      0;
        nPostSweeps     2;
        cacheAgglomeration true;
        nCellsInCoarsestLevel 10;
        agglomerator    faceAreaPair;
        mergeLevels     1;
    }

    "(U.*|k.*|epsilon.*)"
    {
        solver           smoothSolver;
        smoother         GaussSeidel;
        tolerance        1e-8;
        relTol           0;
        nSweeps          1;
    }
}

SIMPLE
{
    nNonOrthogonalCorrectors 2;
    pRefCell 0;
    pRefValue 0;
}

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

RASProperties:

RASModel        realizableKE;

turbulence      on;

printCoeffs     on;

U:

dimensions      [0 1 -1 0 0 0 0];
internalField   uniform (60 0 0);

boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform (60 0 0);
    }
    outlet
    {
        type            zeroGradient;
    }
    side
    {
        type            slip;
    }
    "ahmed.*"
    {
        type            fixedValue;
        value           uniform (0 0 0);
    }
    stilts
    {
        type            fixedValue;
        value           uniform (0 0 0);
    }
    ground
    {
        type            fixedValue;
        value           uniform (0 0 0);
    }
}

p:

dimensions      [0 2 -2 0 0 0 0];
internalField   uniform 0;

boundaryField
{
    inlet
    {
        type            zeroGradient;
    }
    outlet
    {
        type            fixedValue;
        value           uniform 0;
    }
    side
    {
        type            slip;
    }
    "ahmed.*"
    {
        type            zeroGradient;
    }
    stilts
    {
        type            zeroGradient;
    }
    ground
    {
        type            zeroGradient;
    }
}

k:

dimensions      [0 2 -2 0 0];

internalField   uniform 0.135;

boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform 0.135;
    }
    outlet
    {
        type            zeroGradient;
    }
    side
    {
        type            slip;
    }
    "ahmed.*"
    {
        type            kqRWallFunction;
        value           uniform 0.135;
    }
    stilts
    {
        type            kqRWallFunction;
        value           uniform 0.135;
    }
    ground
    {
        type            kqRWallFunction;
        value           uniform 0.135;
    }
}

epsilon:

dimensions      [0 2 -3 0 0 0 0];
internalField   uniform 0.018912309598231;

boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform 0.018912309598231;
    }
    outlet
    {
        type            zeroGradient;
    }
    "ahmed.*"
    {
        type            epsilonWallFunction;
        value           uniform 0.018912309598231;
    }
    stilts
    {
        type            epsilonWallFunction;
        value           uniform 0.018912309598231;
    }
    ground
    {
        type            epsilonWallFunction;
        value           uniform 0.018912309598231;
    }
    side
    {
        type            slip;
    }
}

nut:

dimensions      [0 2 -1 0 0 0 0];
internalField   uniform 0;

boundaryField
{
    inlet
    {
        type            calculated;
        value           uniform 0;
    }
    outlet
    {
        type            calculated;
        value           uniform 0;
    }
    side
    {
        type            calculated;
        value           uniform 0;
    }
    ground
    {
        type            nutkWallFunction;
        value           uniform 0;
    }
    "ahmed.*"
    {
        type            nutkWallFunction;
        value           uniform 0;
    }
    stilts
    {
        type            nutkWallFunction;
        value           uniform 0;
    }
}