Steady-state CFD simulation of a car, Part 2 of 3 (Calculation Set-up)

Turbulence model: 

laminar (until Time = 300)
kEpsilon (until Time = 600)
realizableKE (until the end)

Relaxation factors:
0.1 for all variables

Numerical schemes:
gradSchemes: central difference (cellMDLimited version);
divSchemes: upwind (until 700 time steps), Gamma (until the end)
laplacianSchemes: limited
snGradSchemes: limited

I used limited schemes for grad, laplacian, snGrad, since max non-orthogonality > 60.

Inlet velocity: 10m/s

================================

RASProperties:

RASModel        realizableKE;
turbulence      on;
printCoeffs     on;

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|omega)"
    {
        solver          PBiCG;
        preconditioner  DILU;
        tolerance       1e-8;
        relTol          0;
    }
}
SIMPLE
{
    nNonOrthogonalCorrectors 2;
    pRefCell 0;
    pRefValue 0;
}
relaxationFactors
{
    fields
    {
        p       0.1;
    }
    equations
    {
        U       0.1;
        k       0.1;
        omega   0.1;
        epsilon 0.1;
    }
}

fvSchemes:

ddtSchemes
{
    default         steadyState;
}
gradSchemes
{
    default         cellMDLimited 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               ;
}

U:

dimensions      [0 1 -1 0 0 0 0];
internalField   uniform (10 0 0);
boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform (10 0 0);
    }
    outlet
    {
        type            zeroGradient;
    }
    side
    {
        type            slip;
    }
    car_OBJECT
    {
        type            fixedValue;
        value           uniform (0 0 0);
    }
    ground
    {
        type            fixedValue;
        value           uniform (10 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;
    }
    car_OBJECT
    {
        type            zeroGradient;
    }
    ground
    {
        type            zeroGradient;
    }
}

k:

dimensions      [0 2 -2 0 0];
internalField   uniform 0.375;
boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform 0.375;
    }
    outlet
    {
        type            zeroGradient;
    }
    side
    {
        type            slip;
    }
    car_OBJECT
    {
        type            kqRWallFunction;
        value           uniform 0.375;
    }
    ground
    {
        type            kqRWallFunction;
        value           uniform 0.375;
    }
}

epsilon:

dimensions      [0 2 -3 0 0 0 0];
internalField   uniform 0.08158251199;
boundaryField
{
    inlet
    {
        type            fixedValue;
        value           uniform 0.08158251199;
    }
    outlet
    {
        type            zeroGradient;
    }
    car_OBJECT
    {
        type            epsilonWallFunction;
        value           uniform 0.08158251199;
    }
    ground
    {
        type            epsilonWallFunction;
        value           uniform 0.08158251199;
    }
    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;
    }
    car_OBJECT
    {
        type            nutkWallFunction;
        value           uniform 0;
    }
}