[Yassin-K]

Dear Foamers,

I am using reactingParcelFilmFoam to simulate water particles' cloud.
My problem is that even if I set maxParticleTrack to be 0.5 sec. the solver still simulates the particle to the end of the domain (which takes almost 2 sec to reach).
Here my reactingCloud1Properties:

/*--------------------------------*- C++ -*----------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Version:  6
     \\/     M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    location    "constant";
    object      reactingCloud1Properties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "../initialConditions"

solution
{
    active          true;

    coupled         no;
    transient       yes;

    cellValueSourceCorrection no;
    maxTrackTime    0.5;
    maxCo           0.3;

    sourceTerms
    {
        schemes
        {
            rho             explicit 1;
            U               explicit 1;
            Yi              explicit 1;
            h               explicit 1;
            radiation       explicit 1;
        }
    }

    interpolationSchemes
    {
        rho             cell;
        U               cellPoint;
        thermo:mu       cell;
        T               cell;
        Cp              cell;
        kappa           cell;
        p               cell;
    }

    integrationSchemes
    {
        U               Euler;
        T               analytical;
    }
}

constantProperties
{
    rho0            1000;
    T0              $temp;
    Cp0             4187;

    constantVolume  false;
}

subModels
{
    particleForces
    {
        sphereDrag;
        //gravity;
    }

    injectionModels
    {
        model1
		{
			type            patchInjection;
            SOI             0.0;
            massTotal       $massTotal;
            parcelBasisType mass;
            patchName       inlet;
            duration        $duration;
            parcelsPerSecond $nParcels;
            U0              $U;
            flowRateProfile constant 1;
            sizeDistribution
            {
                type         RosinRammler;
                RosinRammlerDistribution
                {
                    minValue        $minValue;
                    maxValue        $maxValue;
                    d               $d;
                    n               $n;
                }
            }
		}
    }

    dispersionModel none;

    patchInteractionModel standardWallInteraction;

    heatTransferModel none;

    compositionModel singleMixtureFraction;

    phaseChangeModel none;

    devolatilisationModel none;

    surfaceReactionModel none;

    stochasticCollisionModel none;

    surfaceFilmModel none;//thermoSurfaceFilm;

    radiation       off;

    standardWallInteractionCoeffs
    {
        type            rebound;
    }

    singleMixtureFractionCoeffs
    {
        phases
        (
            gas
            {
            }
            liquid
            {
                H2O         1;
            }
            solid
            {
            }
        );
        YGasTot0        0;
        YLiquidTot0     1;
        YSolidTot0      0;
    }

    thermoSurfaceFilmCoeffs
    {
        interactionType absorb;
    }
}


cloudFunctions
{}


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

[Tobi]

Hi,


out of the box and after a fast code analysis, for me it seems that the maxTrackTime parameter just matters if you have the transient mode set to off. In your case it is turned on.


Here some snipped of where the maxTrackTime is used

 if (steadyState())                                                          
    {                                                                           
        dict_.lookup("calcFrequency") >> calcFrequency_;                        
        dict_.lookup("maxTrackTime") >> maxTrackTime_;                          
                                                                                
        if (coupled_)                                                           
        {                                                                       
            dict_.subDict("sourceTerms").lookup("resetOnStartup")               
                >> resetSourcesOnStartup_;                                      
        }                                                                       
    }

bool Foam::cloudSolution::canEvolve()                                           
{                                                                               
    if (transient_)                                                             
    {                                                                           
        trackTime_ = mesh_.time().deltaTValue();                                
    }                                                                           
    else                                                                        
    {                                                                           
        trackTime_ = maxTrackTime_;                                             
    }                                                                           
                                                                                
    return solveThisStep();                                                     
}