diff --git a/applications/solvers/combustion/SLFMFoam/EEqn.H b/applications/solvers/combustion/SLFMFoam/EEqn.H
new file mode 100644
index 000000000..8239d4462
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/EEqn.H
@@ -0,0 +1,33 @@
+{
+ volScalarField& he = thermo.he();
+
+ fvScalarMatrix EEqn
+ (
+ mvConvection->fvmDiv(phi, he)
+ + (
+ he.name() == "e"
+ ? fvc::div(phi, volScalarField("Ekp", 0.5*magSqr(U) + p/rho))
+ : fvc::div(phi, volScalarField("K", 0.5*magSqr(U)))
+ )
+ - fvm::laplacian(turbulence->alphaEff(), he)
+ ==
+ rho*(U&g)
+ + parcels.Sh(he)
+ + radiation->Sh(thermo)
+ + combustion->Sh()
+ + fvOptions(rho, he)
+ );
+
+ EEqn.relax();
+
+ fvOptions.constrain(EEqn);
+
+ EEqn.solve();
+
+ fvOptions.correct(he);
+ thermo.correct();
+ radiation->correct();
+
+ Info<< "T gas min/max = " << min(T).value() << ", "
+ << max(T).value() << endl;
+}
diff --git a/applications/solvers/combustion/SLFMFoam/Make/files b/applications/solvers/combustion/SLFMFoam/Make/files
new file mode 100644
index 000000000..0df9202d9
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/Make/files
@@ -0,0 +1,3 @@
+SLFMFoam.C
+
+EXE = $(FOAM_APPBIN)/SLFMFoam
diff --git a/applications/solvers/combustion/SLFMFoam/Make/options b/applications/solvers/combustion/SLFMFoam/Make/options
new file mode 100644
index 000000000..f7f22123e
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/Make/options
@@ -0,0 +1,55 @@
+EXE_INC = \
+ -I. \
+ -I$(LIB_SRC)/finiteVolume/lnInclude \
+ -I${LIB_SRC}/meshTools/lnInclude \
+ -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+ -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+ -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+ -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+ -I$(LIB_SRC)/lagrangian/coalCombustion/lnInclude \
+ -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+ -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/properties/liquidProperties/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/properties/liquidMixtureProperties/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/properties/solidProperties/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/properties/solidMixtureProperties/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/thermophysicalFunctions/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
+ -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
+ -I$(LIB_SRC)/ODE/lnInclude \
+ -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+ -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
+ -I$(LIB_SRC)/combustionModels/lnInclude \
+ -I$(LIB_SRC)/sampling/lnInclude
+
+
+EXE_LIBS = \
+ -lfiniteVolume \
+ -lmeshTools \
+ -lturbulenceModels \
+ -lcompressibleTurbulenceModels \
+ -llagrangian \
+ -llagrangianIntermediate \
+ -llagrangianTurbulence \
+ -lspecie \
+ -lcompressibleTransportModels \
+ -lfluidThermophysicalModels \
+ -lliquidProperties \
+ -lliquidMixtureProperties \
+ -lsolidProperties \
+ -lsolidMixtureProperties \
+ -lthermophysicalFunctions \
+ -lreactionThermophysicalModels \
+ -lSLGThermo \
+ -lchemistryModel \
+ -lradiationModels \
+ -lODE \
+ -lregionModels \
+ -lsurfaceFilmModels \
+ -lcombustionModels \
+ -lfvOptions \
+ -lsampling
diff --git a/applications/solvers/combustion/SLFMFoam/SLFMFoam.C b/applications/solvers/combustion/SLFMFoam/SLFMFoam.C
new file mode 100644
index 000000000..ba96da7ff
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/SLFMFoam.C
@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see .
+
+Application
+ simpleReactingParcelFoam
+
+Description
+ Steady state solver for compressible, turbulent flow with reacting,
+ multiphase particle clouds and optional sources/constraints.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "turbulentFluidThermoModel.H"
+#include "basicReactingMultiphaseCloud.H"
+#include "rhoCombustionModel.H"
+#include "radiationModel.H"
+#include "IOporosityModelList.H"
+#include "fvOptions.H"
+#include "SLGThermo.H"
+#include "simpleControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+ #include "postProcess.H"
+
+ #include "setRootCase.H"
+ #include "createTime.H"
+ #include "createMesh.H"
+ #include "createControl.H"
+ #include "createFields.H"
+ #include "createFieldRefs.H"
+ #include "createFvOptions.H"
+ #include "initContinuityErrs.H"
+
+ turbulence->validate();
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ Info<< "\nStarting time loop\n" << endl;
+
+ while (simple.loop())
+ {
+ Info<< "Time = " << runTime.timeName() << nl << endl;
+
+ parcels.evolve();
+
+ // --- Pressure-velocity SIMPLE corrector loop
+ {
+ #include "UEqn.H"
+ #include "YEqn.H"
+ #include "EEqn.H"
+ #include "pEqn.H"
+ }
+
+ turbulence->correct();
+
+ runTime.write();
+
+ Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+ << " ClockTime = " << runTime.elapsedClockTime() << " s"
+ << nl << endl;
+ }
+
+ Info<< "End\n" << endl;
+
+ return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/solvers/combustion/SLFMFoam/UEqn.H b/applications/solvers/combustion/SLFMFoam/UEqn.H
new file mode 100644
index 000000000..a29d4b8c5
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/UEqn.H
@@ -0,0 +1,21 @@
+ MRF.correctBoundaryVelocity(U);
+
+ tmp tUEqn
+ (
+ fvm::div(phi, U)
+ + MRF.DDt(rho, U)
+ + turbulence->divDevRhoReff(U)
+ ==
+ rho()*g
+ + parcels.SU(U)
+ + fvOptions(rho, U)
+ );
+ fvVectorMatrix& UEqn = tUEqn.ref();
+
+ UEqn.relax();
+
+ fvOptions.constrain(UEqn);
+
+ solve(UEqn == -fvc::grad(p));
+
+ fvOptions.correct(U);
diff --git a/applications/solvers/combustion/SLFMFoam/YEqn.H b/applications/solvers/combustion/SLFMFoam/YEqn.H
new file mode 100644
index 000000000..20d55a8d5
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/YEqn.H
@@ -0,0 +1,53 @@
+tmp> mvConvection
+(
+ fv::convectionScheme::New
+ (
+ mesh,
+ fields,
+ phi,
+ mesh.divScheme("div(phi,Yi_h)")
+ )
+);
+
+{
+ combustion->correct();
+ dQ = combustion->dQ();
+ label inertIndex = -1;
+ volScalarField Yt(0.0*Y[0]);
+
+ forAll(Y, i)
+ {
+ if (Y[i].name() != inertSpecie)
+ {
+ volScalarField& Yi = Y[i];
+
+ fvScalarMatrix YEqn
+ (
+ mvConvection->fvmDiv(phi, Yi)
+ - fvm::laplacian(turbulence->muEff(), Yi)
+ ==
+ parcels.SYi(i, Yi)
+ + combustion->R(Yi)
+ + fvOptions(rho, Yi)
+ );
+
+ YEqn.relax();
+
+ fvOptions.constrain(YEqn);
+
+ YEqn.solve(mesh.solver("Yi"));
+
+ fvOptions.correct(Yi);
+
+ Yi.max(0.0);
+ Yt += Yi;
+ }
+ else
+ {
+ inertIndex = i;
+ }
+ }
+
+ Y[inertIndex] = scalar(1) - Yt;
+ Y[inertIndex].max(0.0);
+}
diff --git a/applications/solvers/combustion/SLFMFoam/createClouds.H b/applications/solvers/combustion/SLFMFoam/createClouds.H
new file mode 100644
index 000000000..954b74e06
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/createClouds.H
@@ -0,0 +1,9 @@
+Info<< "\nConstructing reacting cloud" << endl;
+basicReactingMultiphaseCloud parcels
+(
+ "reactingCloud1",
+ rho,
+ U,
+ g,
+ slgThermo
+);
diff --git a/applications/solvers/combustion/SLFMFoam/createFieldRefs.H b/applications/solvers/combustion/SLFMFoam/createFieldRefs.H
new file mode 100644
index 000000000..5842906a6
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/createFieldRefs.H
@@ -0,0 +1,2 @@
+const volScalarField& T = thermo.T();
+const volScalarField& psi = thermo.psi();
diff --git a/applications/solvers/combustion/SLFMFoam/createFields.H b/applications/solvers/combustion/SLFMFoam/createFields.H
new file mode 100644
index 000000000..03413049b
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/createFields.H
@@ -0,0 +1,123 @@
+#include "readGravitationalAcceleration.H"
+
+Info<< "Creating combustion model\n" << endl;
+
+autoPtr combustion
+(
+ combustionModels::rhoCombustionModel::New(mesh)
+);
+
+rhoReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+SLGThermo slgThermo(mesh, thermo);
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+ FatalErrorInFunction
+ << "Specified inert specie '" << inertSpecie << "' not found in "
+ << "species list. Available species:" << composition.species()
+ << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+
+volScalarField rho
+(
+ IOobject
+ (
+ "rho",
+ runTime.timeName(),
+ mesh,
+ IOobject::NO_READ,
+ IOobject::AUTO_WRITE
+ ),
+ thermo.rho()
+);
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+ IOobject
+ (
+ "U",
+ runTime.timeName(),
+ mesh,
+ IOobject::MUST_READ,
+ IOobject::AUTO_WRITE
+ ),
+ mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+ dimensionedScalar::lookupOrDefault
+ (
+ "rhoMax",
+ simple.dict(),
+ dimDensity,
+ GREAT
+ )
+);
+
+dimensionedScalar rhoMin
+(
+ dimensionedScalar::lookupOrDefault
+ (
+ "rhoMin",
+ simple.dict(),
+ dimDensity,
+ 0
+ )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr turbulence
+(
+ compressible::turbulenceModel::New
+ (
+ rho,
+ U,
+ phi,
+ thermo
+ )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating multi-variate interpolation scheme\n" << endl;
+multivariateSurfaceInterpolationScheme::fieldTable fields;
+
+forAll(Y, i)
+{
+ fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+volScalarField dQ
+(
+ IOobject
+ (
+ "dQ",
+ runTime.timeName(),
+ mesh,
+ IOobject::NO_READ,
+ IOobject::AUTO_WRITE
+ ),
+ mesh,
+ dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
+);
+
+#include "createMRF.H"
+#include "createRadiationModel.H"
+#include "createClouds.H"
diff --git a/applications/solvers/combustion/SLFMFoam/pEqn.H b/applications/solvers/combustion/SLFMFoam/pEqn.H
new file mode 100644
index 000000000..055eff6f0
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/pEqn.H
@@ -0,0 +1,57 @@
+{
+ // Thermodynamic density needs to be updated by psi*d(p) after the
+ // pressure solution - done in 2 parts. Part 1:
+ thermo.rho() -= psi*p;
+
+ volScalarField rAU(1.0/UEqn.A());
+ surfaceScalarField rhorAUf("rhorAUf", fvc::interpolate(rho*rAU));
+ volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
+ tUEqn.clear();
+ surfaceScalarField phiHbyA
+ (
+ "phiHbyA",
+ fvc::interpolate(rho)*fvc::flux(HbyA)
+ );
+
+ MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
+
+ // Update the pressure BCs to ensure flux consistency
+ constrainPressure(p, rho, U, phiHbyA, rhorAUf, MRF);
+
+ while (simple.correctNonOrthogonal())
+ {
+ fvScalarMatrix pEqn
+ (
+ fvc::div(phiHbyA)
+ - fvm::laplacian(rhorAUf, p)
+ ==
+ parcels.Srho()
+ + fvOptions(psi, p, rho.name())
+ );
+
+ pEqn.solve();
+
+ if (simple.finalNonOrthogonalIter())
+ {
+ phi = phiHbyA + pEqn.flux();
+ }
+ }
+
+ p.relax();
+
+ // Second part of thermodynamic density update
+ thermo.rho() += psi*p;
+
+ #include "compressibleContinuityErrs.H"
+
+ U = HbyA - rAU*fvc::grad(p);
+ U.correctBoundaryConditions();
+ fvOptions.correct(U);
+
+ rho = thermo.rho();
+ rho = max(rho, rhoMin);
+ rho = min(rho, rhoMax);
+ rho.relax();
+
+ Info<< "p min/max = " << min(p).value() << ", " << max(p).value() << endl;
+}
diff --git a/applications/solvers/combustion/SLFMFoam/pcEqn.H b/applications/solvers/combustion/SLFMFoam/pcEqn.H
new file mode 100644
index 000000000..713f443fc
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/pcEqn.H
@@ -0,0 +1,127 @@
+rho = thermo.rho();
+rho = max(rho, rhoMin);
+rho = min(rho, rhoMax);
+rho.relax();
+
+volScalarField rAU(1.0/UEqn.A());
+volScalarField rAtU(1.0/(1.0/rAU - UEqn.H1()));
+volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
+
+if (pimple.nCorrPISO() <= 1)
+{
+ tUEqn.clear();
+}
+
+if (pimple.transonic())
+{
+ surfaceScalarField phid
+ (
+ "phid",
+ fvc::interpolate(psi)
+ *(
+ fvc::flux(HbyA)
+ + fvc::interpolate(rho*rAU)*fvc::ddtCorr(rho, U, phi)
+ /fvc::interpolate(rho)
+ )
+ );
+
+ MRF.makeRelative(fvc::interpolate(psi), phid);
+
+ surfaceScalarField phic
+ (
+ "phic",
+ fvc::interpolate(rho*(rAtU - rAU))*fvc::snGrad(p)*mesh.magSf()
+ );
+
+ HbyA -= (rAU - rAtU)*fvc::grad(p);
+
+ volScalarField rhorAtU("rhorAtU", rho*rAtU);
+
+ while (pimple.correctNonOrthogonal())
+ {
+ fvScalarMatrix pEqn
+ (
+ fvm::ddt(psi, p)
+ + fvm::div(phid, p)
+ + fvc::div(phic)
+ - fvm::laplacian(rhorAtU, p)
+ ==
+ fvOptions(psi, p, rho.name())
+ );
+
+ pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
+
+ if (pimple.finalNonOrthogonalIter())
+ {
+ phi == phic + pEqn.flux();
+ }
+ }
+}
+else
+{
+ surfaceScalarField phiHbyA
+ (
+ "phiHbyA",
+ (
+ fvc::flux(rho*HbyA)
+ + fvc::interpolate(rho*rAU)*fvc::ddtCorr(rho, U, phi)
+ )
+ );
+
+ MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
+
+ phiHbyA += fvc::interpolate(rho*(rAtU - rAU))*fvc::snGrad(p)*mesh.magSf();
+ HbyA -= (rAU - rAtU)*fvc::grad(p);
+
+ volScalarField rhorAtU("rhorAtU", rho*rAtU);
+
+ // Update the pressure BCs to ensure flux consistency
+ constrainPressure(p, rho, U, phiHbyA, rhorAtU, MRF);
+
+ while (pimple.correctNonOrthogonal())
+ {
+ fvScalarMatrix pEqn
+ (
+ fvm::ddt(psi, p)
+ + fvc::div(phiHbyA)
+ - fvm::laplacian(rhorAtU, p)
+ ==
+ fvOptions(psi, p, rho.name())
+ );
+
+ pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
+
+ if (pimple.finalNonOrthogonalIter())
+ {
+ phi = phiHbyA + pEqn.flux();
+ }
+ }
+}
+
+#include "rhoEqn.H"
+#include "compressibleContinuityErrs.H"
+
+// Explicitly relax pressure for momentum corrector
+p.relax();
+
+U = HbyA - rAtU*fvc::grad(p);
+U.correctBoundaryConditions();
+fvOptions.correct(U);
+K = 0.5*magSqr(U);
+
+if (thermo.dpdt())
+{
+ dpdt = fvc::ddt(p);
+}
+
+// Recalculate density from the relaxed pressure
+rho = thermo.rho();
+rho = max(rho, rhoMin);
+rho = min(rho, rhoMax);
+
+if (!pimple.transonic())
+{
+ rho.relax();
+}
+
+Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value() << endl;
diff --git a/applications/solvers/combustion/SLFMFoam/rhoEqn.H b/applications/solvers/combustion/SLFMFoam/rhoEqn.H
new file mode 100644
index 000000000..b69701e74
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/rhoEqn.H
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see .
+
+Global
+ rhoEqn
+
+Description
+ Solve the continuity for density.
+
+\*---------------------------------------------------------------------------*/
+
+{
+ fvScalarMatrix rhoEqn
+ (
+ fvm::ddt(rho)
+ + fvc::div(phi)
+ ==
+ parcels.Srho(rho)
+ + fvOptions(rho)
+ );
+
+ rhoEqn.solve();
+
+ fvOptions.correct(rho);
+
+ Info<< "rho min/max = " << min(rho).value() << ", " << max(rho).value()
+ << endl;
+}
+
+// ************************************************************************* //
diff --git a/applications/solvers/combustion/SLFMFoam/setRDeltaT.H b/applications/solvers/combustion/SLFMFoam/setRDeltaT.H
new file mode 100644
index 000000000..63398fb00
--- /dev/null
+++ b/applications/solvers/combustion/SLFMFoam/setRDeltaT.H
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see .
+
+\*---------------------------------------------------------------------------*/
+
+{
+ volScalarField& rDeltaT = trDeltaT.ref();
+
+ const dictionary& pimpleDict = pimple.dict();
+
+ // Maximum flow Courant number
+ scalar maxCo(readScalar(pimpleDict.lookup("maxCo")));
+
+ // Maximum time scale
+ scalar maxDeltaT(pimpleDict.lookupOrDefault("maxDeltaT", GREAT));
+
+ // Smoothing parameter (0-1) when smoothing iterations > 0
+ scalar rDeltaTSmoothingCoeff
+ (
+ pimpleDict.lookupOrDefault("rDeltaTSmoothingCoeff", 0.1)
+ );
+
+ // Damping coefficient (1-0)
+ scalar rDeltaTDampingCoeff
+ (
+ pimpleDict.lookupOrDefault("rDeltaTDampingCoeff", 0.2)
+ );
+
+ // Maximum change in cell temperature per iteration
+ // (relative to previous value)
+ scalar alphaTemp(pimpleDict.lookupOrDefault("alphaTemp", 0.05));
+
+
+ Info<< "Time scales min/max:" << endl;
+
+ // Cache old reciprocal time scale field
+ volScalarField rDeltaT0("rDeltaT0", rDeltaT);
+
+ // Flow time scale
+ {
+ rDeltaT.ref() =
+ (
+ fvc::surfaceSum(mag(phi))()()
+ /((2*maxCo)*mesh.V()*rho())
+ );
+
+ // Limit the largest time scale
+ rDeltaT.max(1/maxDeltaT);
+
+ Info<< " Flow = "
+ << gMin(1/rDeltaT.primitiveField()) << ", "
+ << gMax(1/rDeltaT.primitiveField()) << endl;
+ }
+
+ // Reaction source time scale
+ {
+ volScalarField::Internal rDeltaTT
+ (
+ mag
+ (
+ parcels.hsTrans()/(mesh.V()*runTime.deltaT())
+ + combustion->Sh()()
+ )
+ /(
+ alphaTemp
+ *rho()
+ *thermo.Cp()()()
+ *T()
+ )
+ );
+
+ Info<< " Temperature = "
+ << gMin(1/(rDeltaTT.field() + VSMALL)) << ", "
+ << gMax(1/(rDeltaTT.field() + VSMALL)) << endl;
+
+ rDeltaT.ref() = max
+ (
+ rDeltaT(),
+ rDeltaTT
+ );
+ }
+
+ // Update tho boundary values of the reciprocal time-step
+ rDeltaT.correctBoundaryConditions();
+
+ // Spatially smooth the time scale field
+ if (rDeltaTSmoothingCoeff < 1.0)
+ {
+ fvc::smooth(rDeltaT, rDeltaTSmoothingCoeff);
+ }
+
+ // Limit rate of change of time scale
+ // - reduce as much as required
+ // - only increase at a fraction of old time scale
+ if
+ (
+ rDeltaTDampingCoeff < 1.0
+ && runTime.timeIndex() > runTime.startTimeIndex() + 1
+ )
+ {
+ rDeltaT = max
+ (
+ rDeltaT,
+ (scalar(1.0) - rDeltaTDampingCoeff)*rDeltaT0
+ );
+ }
+
+ Info<< " Overall = "
+ << gMin(1/rDeltaT.primitiveField())
+ << ", " << gMax(1/rDeltaT.primitiveField()) << endl;
+}
+
+
+// ************************************************************************* //