Initial commit

applications/solvers/combustion/XiFoam/XiEngineFoam/XiEngineFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2017 OpenFOAM Foundation
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
+Application
+    XiEngineFoam
+
+Description
+    Solver for internal combustion engines.
+
+    Combusting RANS code using the b-Xi two-equation model.
+    Xi may be obtained by either the solution of the Xi transport
+    equation or from an algebraic expression.  Both approaches are
+    based on Gulder's flame speed correlation which has been shown
+    to be appropriate by comparison with the results from the
+    spectral model.
+
+    Strain effects are encorporated directly into the Xi equation
+    but not in the algebraic approximation.  Further work need to be
+    done on this issue, particularly regarding the enhanced removal rate
+    caused by flame compression.  Analysis using results of the spectral
+    model will be required.
+
+    For cases involving very lean Propane flames or other flames which are
+    very strain-sensitive, a transport equation for the laminar flame
+    speed is present.  This equation is derived using heuristic arguments
+    involving the strain time scale and the strain-rate at extinction.
+    the transport velocity is the same as that for the Xi equation.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "engineTime.H"
+#include "engineMesh.H"
+#include "psiuReactionThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "laminarFlameSpeed.H"
+#include "ignition.H"
+#include "Switch.H"
+#include "OFstream.H"
+#include "mathematicalConstants.H"
+#include "pimpleControl.H"
+#include "fvOptions.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Solver for compressible premixed/partially-premixed combustion with"
+        " turbulence modelling in internal combustion engines."
+    );
+
+    #define CREATE_TIME createEngineTime.H
+    #define CREATE_MESH createEngineMesh.H
+    #include "postProcess.H"
+
+    #include "setRootCaseLists.H"
+    #include "createEngineTime.H"
+    #include "createEngineMesh.H"
+    #include "createControl.H"
+    #include "readCombustionProperties.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "createRhoUf.H"
+    #include "initContinuityErrs.H"
+    #include "readEngineTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
+    #include "startSummary.H"
+
+    turbulence->validate();
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readEngineTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
+
+        ++runTime;
+
+        Info<< "Crank angle = " << runTime.theta() << " CA-deg" << endl;
+
+        mesh.move();
+
+        #include "rhoEqn.H"
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        while (pimple.loop())
+        {
+            #include "UEqn.H"
+
+            #include "ftEqn.H"
+            #include "bEqn.H"
+            #include "EauEqn.H"
+            #include "EaEqn.H"
+
+            if (!ign.ignited())
+            {
+                thermo.heu() == thermo.he();
+            }
+
+            // --- Pressure corrector loop
+            while (pimple.correct())
+            {
+                #include "pEqn.H"
+            }
+
+            if (pimple.turbCorr())
+            {
+                turbulence->correct();
+            }
+        }
+
+        #include "logSummary.H"
+
+        rho = thermo.rho();
+
+        runTime.write();
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/XiFoam/XiEngineFoam/logSummary.H

+{
+    const scalar meanP = p.weightedAverage(mesh.V()).value();
+    const scalar meanT = thermo.T().weightedAverage(mesh.V()).value();
+    const scalar meanUp =
+        (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value();
+    const scalar meanB = b.weightedAverage(mesh.V()).value();
+
+    Info<< "Mean pressure:" << meanP << nl
+        << "Mean temperature:" << meanT << nl
+        << "Mean u':" << meanUp << endl;
+
+    if (Pstream::master())
+    {
+        logSummaryFile()
+            << runTime.theta() << tab
+            << meanP << tab
+            << meanT << tab
+            << meanUp << tab
+            << 1 - meanB
+            << endl;
+    }
+}

applications/solvers/combustion/XiFoam/XiEngineFoam/pEqn.H

+rho = thermo.rho();
+
+volScalarField rAU(1.0/UEqn.A());
+surfaceScalarField rhorAUf("rhorAUf", fvc::interpolate(rho*rAU));
+volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
+
+if (pimple.transonic())
+{
+    surfaceScalarField phid
+    (
+        "phid",
+        fvc::interpolate(psi)
+       *(
+            (
+                fvc::flux(HbyA)
+              + MRF.zeroFilter
+                (
+                    rhorAUf*fvc::ddtCorr(rho, U, rhoUf)/fvc::interpolate(rho)
+                )
+            )
+        )
+    );
+
+    fvc::makeRelative(phid, psi, U);
+    MRF.makeRelative(fvc::interpolate(psi), phid);
+
+    while (pimple.correctNonOrthogonal())
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvm::div(phid, p)
+          - fvm::laplacian(rhorAUf, p)
+         ==
+            fvOptions(psi, p, rho.name())
+        );
+
+        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
+
+        if (pimple.finalNonOrthogonalIter())
+        {
+            phi == pEqn.flux();
+        }
+    }
+}
+else
+{
+    surfaceScalarField phiHbyA
+    (
+        "phiHbyA",
+        (
+            fvc::flux(rho*HbyA)
+          + MRF.zeroFilter(rhorAUf*fvc::ddtCorr(rho, U, rhoUf))
+        )
+    );
+
+    fvc::makeRelative(phiHbyA, rho, U);
+    MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
+
+    // Update the pressure BCs to ensure flux consistency
+    constrainPressure(p, rho, U, phiHbyA, rhorAUf, MRF);
+
+    while (pimple.correctNonOrthogonal())
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvc::div(phiHbyA)
+          - fvm::laplacian(rhorAUf, 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"
+
+U = HbyA - rAU*fvc::grad(p);
+U.correctBoundaryConditions();
+fvOptions.correct(U);
+K = 0.5*magSqr(U);
+
+{
+    rhoUf = fvc::interpolate(rho*U);
+    surfaceVectorField n(mesh.Sf()/mesh.magSf());
+    rhoUf += n*(fvc::absolute(phi, rho, U)/mesh.magSf() - (n & rhoUf));
+}
+
+if (thermo.dpdt())
+{
+    dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho, U), p);
+}

applications/solvers/combustion/XiFoam/XiEngineFoam/startSummary.H

+Info<< "Total cylinder mass: " << fvc::domainIntegrate(rho).value() << endl;
+
+autoPtr<OFstream> logSummaryFile;
+
+if (Pstream::master())
+{
+    logSummaryFile.reset
+    (
+        new OFstream
+        (
+            runTime.globalPath()
+           /("logSummary." + runTime.timeName() + ".dat")
+        )
+    );
+
+    logSummaryFile()
+        << "# CA" << "      p" << "        T" << "       u'" << "        c"
+        << endl;
+}

applications/solvers/combustion/XiFoam/XiFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
+Application
+    XiFoam
+
+Group
+    grpCombustionSolvers
+
+Description
+    Solver for compressible premixed/partially-premixed combustion with
+    turbulence modelling.
+
+    Combusting RANS code using the b-Xi two-equation model.
+    Xi may be obtained by either the solution of the Xi transport
+    equation or from an algebraic expression.  Both approaches are
+    based on Gulder's flame speed correlation which has been shown
+    to be appropriate by comparison with the results from the
+    spectral model.
+
+    Strain effects are encorporated directly into the Xi equation
+    but not in the algebraic approximation.  Further work need to be
+    done on this issue, particularly regarding the enhanced removal rate
+    caused by flame compression.  Analysis using results of the spectral
+    model will be required.
+
+    For cases involving very lean Propane flames or other flames which are
+    very strain-sensitive, a transport equation for the laminar flame
+    speed is present.  This equation is derived using heuristic arguments
+    involving the strain time scale and the strain-rate at extinction.
+    the transport velocity is the same as that for the Xi equation.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "psiuReactionThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "laminarFlameSpeed.H"
+#include "ignition.H"
+#include "Switch.H"
+#include "pimpleControl.H"
+#include "fvOptions.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Solver for compressible premixed/partially-premixed combustion with"
+        " turbulence modelling."
+    );
+
+    #include "postProcess.H"
+
+    #include "addCheckCaseOptions.H"
+    #include "setRootCaseLists.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createControl.H"
+    #include "readCombustionProperties.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "initContinuityErrs.H"
+    #include "createTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
+
+    turbulence->validate();
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
+
+        ++runTime;
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        #include "rhoEqn.H"
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        while (pimple.loop())
+        {
+            #include "UEqn.H"
+
+            #include "ftEqn.H"
+            #include "bEqn.H"
+            #include "EauEqn.H"
+            #include "EaEqn.H"
+
+            if (!ign.ignited())
+            {
+                thermo.heu() == thermo.he();
+            }
+
+            // --- Pressure corrector loop
+            while (pimple.correct())
+            {
+                #include "pEqn.H"
+            }
+
+            if (pimple.turbCorr())
+            {
+                turbulence->correct();
+            }
+        }
+
+        rho = thermo.rho();
+
+        runTime.write();
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/XiFoam/bEqn.H

+if (ign.ignited())
+{
+    // progress variable
+    // ~~~~~~~~~~~~~~~~~
+    volScalarField c("c", scalar(1) - b);
+
+    // Unburnt gas density
+    // ~~~~~~~~~~~~~~~~~~~
+    volScalarField rhou(thermo.rhou());
+
+    // Calculate flame normal etc.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    volVectorField n("n", fvc::grad(b));
+
+    volScalarField mgb(mag(n));
+
+    dimensionedScalar dMgb = 1.0e-3*
+        (b*c*mgb)().weightedAverage(mesh.V())
+       /((b*c)().weightedAverage(mesh.V()) + SMALL)
+      + dimensionedScalar("ddMgb", mgb.dimensions(), SMALL);
+
+    mgb += dMgb;
+
+    surfaceVectorField SfHat(mesh.Sf()/mesh.magSf());
+    surfaceVectorField nfVec(fvc::interpolate(n));
+    nfVec += SfHat*(fvc::snGrad(b) - (SfHat & nfVec));
+    nfVec /= (mag(nfVec) + dMgb);
+    surfaceScalarField nf((mesh.Sf() & nfVec));
+    n /= mgb;
+
+
+    #include "StCorr.H"
+
+    // Calculate turbulent flame speed flux
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    surfaceScalarField phiSt("phiSt", fvc::interpolate(rhou*StCorr*Su*Xi)*nf);
+
+    scalar StCoNum = max
+    (
+        mesh.surfaceInterpolation::deltaCoeffs()
+       *mag(phiSt)/(fvc::interpolate(rho)*mesh.magSf())
+    ).value()*runTime.deltaTValue();
+
+    Info<< "Max St-Courant Number = " << StCoNum << endl;
+
+    // Create b equation
+    // ~~~~~~~~~~~~~~~~~
+    fvScalarMatrix bEqn
+    (
+        fvm::ddt(rho, b)
+      + mvConvection->fvmDiv(phi, b)
+      + fvm::div(phiSt, b)
+      - fvm::Sp(fvc::div(phiSt), b)
+      - fvm::laplacian(turbulence->alphaEff(), b)
+     ==
+        fvOptions(rho, b)
+    );
+
+
+    // Add ignition cell contribution to b-equation
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    #include "ignite.H"
+
+
+    // Solve for b
+    // ~~~~~~~~~~~
+    bEqn.relax();
+
+    fvOptions.constrain(bEqn);
+
+    bEqn.solve();
+
+    fvOptions.correct(b);
+
+    Info<< "min(b) = " << min(b).value() << endl;
+
+
+    // Calculate coefficients for Gulder's flame speed correlation
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    volScalarField up(uPrimeCoef*sqrt((2.0/3.0)*turbulence->k()));
+  //volScalarField up(sqrt(mag(diag(n * n) & diag(turbulence->r()))));
+
+    volScalarField epsilon(pow(uPrimeCoef, 3)*turbulence->epsilon());
+
+    volScalarField tauEta(sqrt(thermo.muu()/(rhou*epsilon)));
+
+    volScalarField Reta
+    (
+        up
+      / (
+            sqrt(epsilon*tauEta)
+          + dimensionedScalar("1e-8", up.dimensions(), 1e-8)
+        )
+    );
+
+  //volScalarField l = 0.337*k*sqrt(k)/epsilon;
+  //Reta *= max((l - dimensionedScalar("dl", dimLength, 1.5e-3))/l, 0.0);
+
+    // Calculate Xi flux
+    // ~~~~~~~~~~~~~~~~~
+    surfaceScalarField phiXi
+    (
+        phiSt
+      - fvc::interpolate(fvc::laplacian(turbulence->alphaEff(), b)/mgb)*nf
+      + fvc::interpolate(rho)*fvc::interpolate(Su*(1.0/Xi - Xi))*nf
+    );
+
+
+    // Calculate mean and turbulent strain rates
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    volVectorField Ut(U + Su*Xi*n);
+    volScalarField sigmat((n & n)*fvc::div(Ut) - (n & fvc::grad(Ut) & n));
+
+    volScalarField sigmas
+    (
+        ((n & n)*fvc::div(U) - (n & fvc::grad(U) & n))/Xi
+      + (
+            (n & n)*fvc::div(Su*n)
+          - (n & fvc::grad(Su*n) & n)
+        )*(Xi + scalar(1))/(2*Xi)
+    );
+
+
+    // Calculate the unstrained laminar flame speed
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    volScalarField Su0(unstrainedLaminarFlameSpeed()());
+
+
+    // Calculate the laminar flame speed in equilibrium with the applied strain
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    volScalarField SuInf(Su0*max(scalar(1) - sigmas/sigmaExt, scalar(0.01)));
+
+    if (SuModel == "unstrained")
+    {
+        Su == Su0;
+    }
+    else if (SuModel == "equilibrium")
+    {
+        Su == SuInf;
+    }
+    else if (SuModel == "transport")
+    {
+        // Solve for the strained laminar flame speed
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        volScalarField Rc
+        (
+            (sigmas*SuInf*(Su0 - SuInf) + sqr(SuMin)*sigmaExt)
+            /(sqr(Su0 - SuInf) + sqr(SuMin))
+        );
+
+        fvScalarMatrix SuEqn
+        (
+            fvm::ddt(rho, Su)
+          + fvm::div(phi + phiXi, Su, "div(phiXi,Su)")
+          - fvm::Sp(fvc::div(phiXi), Su)
+          ==
+          - fvm::SuSp(-rho*Rc*Su0/Su, Su)
+          - fvm::SuSp(rho*(sigmas + Rc), Su)
+          + fvOptions(rho, Su)
+        );
+
+        SuEqn.relax();
+
+        fvOptions.constrain(SuEqn);
+
+        SuEqn.solve();
+
+        fvOptions.correct(Su);
+
+        // Limit the maximum Su
+        // ~~~~~~~~~~~~~~~~~~~~
+        Su.min(SuMax);
+        Su.max(SuMin);
+    }
+    else
+    {
+        FatalError
+            << args.executable() << " : Unknown Su model " << SuModel
+            << abort(FatalError);
+    }
+
+
+    // Calculate Xi according to the selected flame wrinkling model
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (XiModel == "fixed")
+    {
+        // Do nothing, Xi is fixed!
+    }
+    else if (XiModel == "algebraic")
+    {
+        // Simple algebraic model for Xi based on Gulders correlation
+        // with a linear correction function to give a plausible profile for Xi
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        Xi == scalar(1) +
+            (scalar(1) + (2*XiShapeCoef)*(scalar(0.5) - b))
+           *XiCoef*sqrt(up/(Su + SuMin))*Reta;
+    }
+    else if (XiModel == "transport")
+    {
+        // Calculate Xi transport coefficients based on Gulders correlation
+        // and DNS data for the rate of generation
+        // with a linear correction function to give a plausible profile for Xi
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        volScalarField XiEqStar
+        (
+            scalar(1.001) + XiCoef*sqrt(up/(Su + SuMin))*Reta
+        );
+
+        volScalarField XiEq
+        (
+            scalar(1.001)
+          + (
+                scalar(1)
+              + (2*XiShapeCoef)
+               *(scalar(0.5) - min(max(b, scalar(0)), scalar(1)))
+            )*(XiEqStar - scalar(1.001))
+        );
+
+        volScalarField Gstar(0.28/tauEta);
+        volScalarField R(Gstar*XiEqStar/(XiEqStar - scalar(1)));
+        volScalarField G(R*(XiEq - scalar(1.001))/XiEq);
+
+        //R *= (Gstar + 2*mag(dev(symm(fvc::grad(U)))))/Gstar;
+
+        // Solve for the flame wrinkling
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        fvScalarMatrix XiEqn
+        (
+            fvm::ddt(rho, Xi)
+          + fvm::div(phi + phiXi, Xi, "div(phiXi,Xi)")
+          - fvm::Sp(fvc::div(phiXi), Xi)
+         ==
+            rho*R
+          - fvm::Sp(rho*(R - G), Xi)
+          - fvm::Sp
+            (
+                rho*max
+                (
+                    sigmat - sigmas,
+                    dimensionedScalar(sigmat.dimensions(), Zero)
+                ),
+                Xi
+            )
+          + fvOptions(rho, Xi)
+        );
+
+        XiEqn.relax();
+
+        fvOptions.constrain(XiEqn);
+
+        XiEqn.solve();
+
+        fvOptions.correct(Xi);
+
+        // Correct boundedness of Xi
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+        Xi.max(1.0);
+        Info<< "max(Xi) = " << max(Xi).value() << endl;
+        Info<< "max(XiEq) = " << max(XiEq).value() << endl;
+    }
+    else
+    {
+        FatalError
+            << args.executable() << " : Unknown Xi model " << XiModel
+            << abort(FatalError);
+    }
+
+    Info<< "Combustion progress = "
+        << 100*(scalar(1) - b)().weightedAverage(mesh.V()).value() << "%"
+        << endl;
+
+    St = Xi*Su;
+}

applications/solvers/combustion/XiFoam/createFieldRefs.H

+const volScalarField& psi = thermo.psi();

applications/solvers/combustion/XiFoam/createFields.H

+Info<< "Reading thermophysical properties\n" << endl;
+
+autoPtr<psiuReactionThermo> pThermo
+(
+    psiuReactionThermo::New(mesh)
+);
+psiuReactionThermo& thermo = pThermo();
+thermo.validate(args.executable(), "ha", "ea");
+
+basicSpecieMixture& composition = thermo.composition();
+
+volScalarField rho
+(
+    IOobject
+    (
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
+
+volScalarField& p = thermo.p();
+
+volScalarField& b = composition.Y("b");
+Info<< "min(b) = " << min(b).value() << endl;
+
+
+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());
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+
+Info<< "Creating field Xi\n" << endl;
+volScalarField Xi
+(
+    IOobject
+    (
+        "Xi",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+
+Info<< "Creating the unstrained laminar flame speed\n" << endl;
+autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
+(
+    laminarFlameSpeed::New(thermo)
+);
+
+
+Info<< "Reading strained laminar flame speed field Su\n" << endl;
+volScalarField Su
+(
+    IOobject
+    (
+        "Su",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+dimensionedScalar SuMin = 0.01*Su.average();
+dimensionedScalar SuMax = 4*Su.average();
+
+Info<< "Calculating turbulent flame speed field St\n" << endl;
+volScalarField St
+(
+    IOobject
+    (
+        "St",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    Xi*Su
+);
+
+
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+if (composition.contains("ft"))
+{
+    fields.add(composition.Y("ft"));
+}
+
+fields.add(b);
+fields.add(thermo.he());
+fields.add(thermo.heu());
+
+#include "createDpdt.H"
+
+#include "createK.H"
+
+#include "createMRF.H"
+#include "createFvOptions.H"

applications/solvers/combustion/XiFoam/ftEqn.H

+tmp<fv::convectionScheme<scalar>> mvConvection
+(
+    fv::convectionScheme<scalar>::New
+    (
+        mesh,
+        fields,
+        phi,
+        mesh.divScheme("div(phi,ft_b_ha_hau)")
+    )
+);
+
+if (composition.contains("ft"))
+{
+    volScalarField& ft = composition.Y("ft");
+
+    fvScalarMatrix ftEqn
+    (
+        fvm::ddt(rho, ft)
+      + mvConvection->fvmDiv(phi, ft)
+      - fvm::laplacian(turbulence->alphaEff(), ft)
+     ==
+        fvOptions(rho, ft)
+    );
+
+    fvOptions.constrain(ftEqn);
+
+    ftEqn.solve();
+
+    fvOptions.correct(ft);
+}

applications/solvers/combustion/XiFoam/pEqn.H

+rho = thermo.rho();
+
+volScalarField rAU(1.0/UEqn.A());
+surfaceScalarField rhorAUf("rhorAUf", fvc::interpolate(rho*rAU));
+volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
+
+if (pimple.transonic())
+{
+    surfaceScalarField phid
+    (
+        "phid",
+        fvc::interpolate(psi)
+       *(
+            fvc::flux(HbyA)
+          + rhorAUf*fvc::ddtCorr(rho, U, phi)/fvc::interpolate(rho)
+        )
+    );
+
+    MRF.makeRelative(fvc::interpolate(psi), phid);
+
+    while (pimple.correctNonOrthogonal())
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvm::div(phid, p)
+          - fvm::laplacian(rhorAUf, p)
+         ==
+            fvOptions(psi, p, rho.name())
+        );
+
+        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
+
+        if (pimple.finalNonOrthogonalIter())
+        {
+            phi == pEqn.flux();
+        }
+    }
+}
+else
+{
+    surfaceScalarField phiHbyA
+    (
+        "phiHbyA",
+        (
+            fvc::flux(rho*HbyA)
+          + rhorAUf*fvc::ddtCorr(rho, U, phi)
+        )
+    );
+
+    MRF.makeRelative(phiHbyA);
+
+    // Update the pressure BCs to ensure flux consistency
+    constrainPressure(p, rho, U, phiHbyA, rhorAUf, MRF);
+
+    while (pimple.correctNonOrthogonal())
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvc::div(phiHbyA)
+          - fvm::laplacian(rhorAUf, 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"
+
+U = HbyA - rAU*fvc::grad(p);
+U.correctBoundaryConditions();
+fvOptions.correct(U);
+K = 0.5*magSqr(U);
+
+if (thermo.dpdt())
+{
+    dpdt = fvc::ddt(p);
+}

applications/solvers/combustion/XiFoam/readCombustionProperties.H

+    Info<< "Reading combustion properties\n" << endl;
+
+    IOdictionary combustionProperties
+    (
+        IOobject
+        (
+            "combustionProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+    const word SuModel
+    (
+        combustionProperties.get<word>("SuModel")
+    );
+
+    dimensionedScalar sigmaExt
+    (
+        "sigmaExt", dimless/dimTime, combustionProperties
+    );
+
+    const word XiModel
+    (
+        combustionProperties.get<word>("XiModel")
+    );
+
+    dimensionedScalar XiCoef
+    (
+        "XiCoef", dimless, combustionProperties
+    );
+
+    dimensionedScalar XiShapeCoef
+    (
+        "XiShapeCoef", dimless, combustionProperties
+    );
+
+    dimensionedScalar uPrimeCoef
+    (
+        "uPrimeCoef", dimless, combustionProperties
+    );
+
+    ignition ign(combustionProperties, runTime, mesh);

applications/solvers/combustion/chemFoam/Make/files

+chemFoam.C
+
+EXE = $(FOAM_APPBIN)/chemFoam

applications/solvers/combustion/chemFoam/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/ODE/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/thermophysicalProperties/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lfluidThermophysicalModels \
+    -lreactionThermophysicalModels \
+    -lchemistryModel \
+    -lthermophysicalProperties

applications/solvers/combustion/chemFoam/YEqn.H

+{
+    forAll(Y, specieI)
+    {
+        volScalarField& Yi = Y[specieI];
+
+        solve
+        (
+            fvm::ddt(rho, Yi) - chemistry.RR(specieI),
+            mesh.solver("Yi")
+        );
+    }
+}

applications/solvers/combustion/chemFoam/chemFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
+Application
+    chemFoam
+
+Group
+    grpCombustionSolvers
+
+Description
+    Solver for chemistry problems, designed for use on single cell cases to
+    provide comparison against other chemistry solvers, that uses a single cell
+    mesh, and fields created from the initial conditions.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "psiReactionThermo.H"
+#include "BasicChemistryModel.H"
+#include "reactingMixture.H"
+#include "chemistrySolver.H"
+#include "OFstream.H"
+#include "thermoPhysicsTypes.H"
+#include "basicSpecieMixture.H"
+#include "hexCellFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Solver for chemistry problems, designed for use on single cell cases"
+        " to provide comparison against other chemistry solvers"
+    );
+
+    argList::noParallel();
+
+    #define CREATE_MESH createSingleCellMesh.H
+    #define NO_CONTROL
+    #include "postProcess.H"
+
+    #include "setRootCaseLists.H"
+    #include "createTime.H"
+    #include "createSingleCellMesh.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "readInitialConditions.H"
+    #include "createControls.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readControls.H"
+
+        #include "setDeltaT.H"
+
+        ++runTime;
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        #include "solveChemistry.H"
+        #include "YEqn.H"
+        #include "hEqn.H"
+        #include "pEqn.H"
+
+        #include "output.H"
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "Number of steps = " << runTime.timeIndex() << nl;
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/chemFoam/createBaseFields.H

+// write base thermo fields - not registered since will be re-read by
+// thermo package
+
+Info<< "Creating base fields for time " << runTime.timeName() << endl;
+{
+    volScalarField Ydefault
+    (
+        IOobject
+        (
+            "Ydefault",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        dimensionedScalar("Ydefault", dimless, 1)
+    );
+
+    Ydefault.write();
+
+    volScalarField p
+    (
+        IOobject
+        (
+            "p",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        dimensionedScalar("p", dimPressure, p0)
+    );
+
+    p.write();
+
+    volScalarField T
+    (
+        IOobject
+        (
+            "T",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        dimensionedScalar("T", dimTemperature, T0)
+    );
+
+    T.write();
+}

applications/solvers/combustion/chemFoam/createControls.H

+bool adjustTimeStep(runTime.controlDict().get<bool>("adjustTimeStep"));
+
+scalar maxDeltaT(runTime.controlDict().get<scalar>("maxDeltaT"));

applications/solvers/combustion/chemFoam/createFieldRefs.H

+BasicChemistryModel<psiReactionThermo>& chemistry = pChemistry();
+scalar dtChem = refCast<const BasicChemistryModel<psiReactionThermo>>
+(
+    chemistry
+).deltaTChem()[0];
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+volScalarField& p = thermo.p();

applications/solvers/combustion/chemFoam/createFields.H

+    if (mesh.nCells() != 1)
+    {
+        FatalErrorInFunction
+            << "Solver only applicable to single cell cases"
+            << exit(FatalError);
+    }
+
+    Info<< "Reading initial conditions.\n" << endl;
+    IOdictionary initialConditions
+    (
+        IOobject
+        (
+            "initialConditions",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+    scalar p0 = initialConditions.get<scalar>("p");
+    scalar T0 = initialConditions.get<scalar>("T");
+
+    #include "createBaseFields.H"
+
+    Info<< "Reading thermophysical properties\n" << endl;
+    autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
+    psiReactionThermo& thermo = pThermo();
+    thermo.validate(args.executable(), "h");
+
+    autoPtr<BasicChemistryModel<psiReactionThermo>> pChemistry
+    (
+        BasicChemistryModel<psiReactionThermo>::New(thermo)
+    );
+
+    volScalarField rho
+    (
+        IOobject
+        (
+            "rho",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        thermo.rho()
+    );
+
+    volScalarField Rspecific
+    (
+        IOobject
+        (
+            "Rspecific",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh,
+        dimensionedScalar(dimEnergy/dimMass/dimTemperature, Zero)
+    );
+
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedVector(dimVelocity, Zero)
+    );
+
+    #include "createPhi.H"
+
+    OFstream post(args.path()/"chemFoam.out");
+    post<< "# Time" << token::TAB << "Temperature [K]" << token::TAB
+        << "Pressure [Pa]" << endl;

applications/solvers/combustion/chemFoam/createSingleCellMesh.H

+Info<< "Constructing single cell mesh" << nl << endl;
+
+Foam::simplifiedMeshes::hexCellFvMesh mesh(runTime);