[Alczem]

Hello!


I am trying to figure out the proper way to use Local Time Stepping with icoReactingMultiphaseInterFoam.


My simulation includes two fluids and mass transfer (Lee model) from one phase to the other. The mesh has 2M cells (cfMesh) and the computation time seems quite long, so I am interested in using LTS to speed things up since I am interested in a steady state. I read about STLS and CoEuler, which my case accepts (as it seems to be running) but I am not sure about the settings. For instance, can we use several outer iterations (in PIMPLE) while using LTS?


If anyone has any experience with LTS I would gladly hear more about this Thanks for the help!


fvSolution

solvers
{
    ".*(rho|rhoFinal)"
    {
        solver PCG;
        preconditioner DIC;
        tolerance 1e-05;
        relTol 0.1;
    }

    "alpha.*"
    {
        solver          PBiCG;
        preconditioner  DILU;
        tolerance       1e-08;
        relTol          0.0;

        cAlphas          ((N2 and gas) 1);

        nAlphaCorr      1;
        nAlphaSubCycles 3;
        
        MULESCorr    true;

        // Compressiion factor for species in each alpha phase
        // NOTE: It should be similar to cAlpha
        cYi             1;
    }

    "pcorr.*"
    {
        solver          PCG;
        preconditioner  DIC;
        tolerance       1e-5;
        relTol          0;
    }

    "(epsilon.*|k.*)"
    {
        solver          smoothSolver;
        smoother        symGaussSeidel;
        tolerance       1e-8;
        relTol          0.1;
    };
    
    "U.*"
    {
        solver             PBiCGStab;
        preconditioner     DILU;
        tolerance         1e-8;
        relTol             0.1;
    }

    "T.*"
    {
        solver          PBiCGStab;
        preconditioner  DILU;
        tolerance       1e-08;
        relTol          0.05;
        residualAlpha   1e-5;
    }

    p_rgh
    {
        solver          GAMG;
        smoother  GaussSeidel;
        tolerance       1e-6;
        relTol          0.05 ;
        nPreSweeps      0;
        nPostSweeps     2;
        cacheAgglomeration true;
        nCellsInCoarsestLevel 20;
        agglomerator    faceAreaPair;
        mergeLevels     1;
        maxIter            50;
    };

    p_rghFinal
    {
        $p_rgh;
        relTol          0;
    };

    "Xvapour_N2.gas.*"
    {
        solver          PBiCGStab;
        preconditioner  DILU;
        tolerance       1e-08;
        relTol          0.0;
    }
}

PIMPLE
{
    momentumPredictor   true;
    nOuterCorrectors    1;
    nCorrectors         1;
    nNonOrthogonalCorrectors 1;
    turbOnFinalIterOnly        false;    
    
    residualControl
    {
        "(p_rgh)"
        {
            relTol          0;
            tolerance       0.001;
        }
        "(k|epsilon|omega)"
        {
            relTol          0;
            tolerance       0.001;
        }
        "(T)"
        {
            relTol          0;
            tolerance       0.0001;
        }
    }
    
}

relaxationFactors
{
    fields
    {
    }
    equations
    {
        "(k|epsilon)"            0.7;
        "(h.*|e.*)"                0.5
        p_rgh                    0.5;
        T                        0.5;
        ".*Final"                1;
    }
}

fvSchemes

ddtSchemes
{
    //default CoEuler phi maxCo 1;
    default SLTS phi rho 0.7;
    //default        steadyState;
}

gradSchemes
{
    default         cellLimited Gauss linear 1;
    grad(p)         Gauss linear 1;
    //grad(U)            cellMDLimited Gauss linear 0.333;
    //default            Gauss linear;
}

divSchemes
{
    div(rhoPhi,U)           Gauss linearUpwind default;

    "div\(phi,alpha.*\)"    Gauss vanLeer;
    "div\(phir,alpha.*\)"   Gauss linear;

    "div\(Yiphir,alpha.*\)" Gauss linear;
    "div\(phi,.*\.gas.*\)"  Gauss vanLeer;

    div(((rho*nuEff)*dev2(T(grad(U))))) Gauss linear;

    div(phi,T)              Gauss linearUpwind default;
    
    div(rhoPhi,epsilon)        bounded Gauss upwind;
    div(rhoPhi,k)           bounded Gauss upwind;

    div((alpha.gas*U))      Gauss linear;
    div((alpha.liquid*U))   Gauss linear;

    div((p*U))              Gauss linear;
}

laplacianSchemes
{
    default         Gauss linear limited 1;
}

interpolationSchemes
{
    default         linear;
}

snGradSchemes
{
    default         limited 1;
}


fluxRequired
{
    default         no;
    p_rgh           ;
    alpha.gas       ;
    alpha.N2    ;
    Xvapour_N2.gas     ;
}