Initial commit

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/KTS/KTS.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2012 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/>.
+
+Class
+    Foam::XiGModels::KTS
+
+Description
+    Simple Kolmogorov time-scale (KTS) model for the flame-wrinling generation
+    rate.
+
+SourceFiles
+    KTS.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef KTS_H
+#define KTS_H
+
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiGModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class KTS Declaration
+\*---------------------------------------------------------------------------*/
+
+class KTS
+:
+    public XiGModel
+{
+    // Private data
+
+        scalar GEtaCoef_;
+
+
+    // Private Member Functions
+
+        //- No copy construct
+        KTS(const KTS&) = delete;
+
+        //- No copy assignment
+        void operator=(const KTS&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("KTS");
+
+
+    // Constructors
+
+        //- Construct from components
+        KTS
+        (
+            const dictionary& XiGProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su
+        );
+
+
+    //- Destructor
+    virtual ~KTS();
+
+
+    // Member Functions
+
+        //- Return the flame-wrinkling generation rate
+        virtual tmp<volScalarField> G() const;
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiGProperties);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace XiGModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModel.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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(XiGModel, 0);
+    defineRunTimeSelectionTable(XiGModel, dictionary);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiGModel::XiGModel
+(
+    const dictionary& XiGProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su
+)
+:
+    XiGModelCoeffs_
+    (
+        XiGProperties.subDict
+        (
+            XiGProperties.get<word>("XiGModel") + "Coeffs"
+        )
+    ),
+    thermo_(thermo),
+    turbulence_(turbulence),
+    Su_(Su)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiGModel::~XiGModel()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::XiGModel::read(const dictionary& XiGProperties)
+{
+    XiGModelCoeffs_ = XiGProperties.optionalSubDict(type() + "Coeffs");
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModel.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+Class
+    Foam::XiGModel
+
+Description
+    Base-class for all Xi generation models used by the b-Xi combustion model.
+    See Technical Report SH/RE/01R for details on the PDR modelling. For details
+    on the use of XiGModel see \link XiModel.H \endlink. The model available is
+    \link instabilityG.H \endlink
+
+SourceFiles
+    XiGModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef XiGModel_H
+#define XiGModel_H
+
+#include "IOdictionary.H"
+#include "psiuReactionThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class XiGModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class XiGModel
+{
+
+protected:
+
+    // Protected data
+
+        dictionary XiGModelCoeffs_;
+
+        const psiuReactionThermo& thermo_;
+        const compressible::RASModel& turbulence_;
+        const volScalarField& Su_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- No copy construct
+        XiGModel(const XiGModel&) = delete;
+
+        //- No copy assignment
+        void operator=(const XiGModel&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("XiGModel");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            XiGModel,
+            dictionary,
+            (
+                const dictionary& XiGProperties,
+                const psiuReactionThermo& thermo,
+                const compressible::RASModel& turbulence,
+                const volScalarField& Su
+            ),
+            (
+                XiGProperties,
+                thermo,
+                turbulence,
+                Su
+            )
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected XiG model
+        static autoPtr<XiGModel> New
+        (
+            const dictionary& XiGProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        XiGModel
+        (
+            const dictionary& XiGProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su
+        );
+
+
+    //- Destructor
+    virtual ~XiGModel();
+
+
+    // Member Functions
+
+        //- Return the flame-wrinkling generation rate
+        virtual tmp<volScalarField> G() const = 0;
+
+        //- Return the flame diffusivity
+        virtual tmp<volScalarField> Db() const
+        {
+            return turbulence_.muEff();
+        }
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiGProperties) = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModelNew.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 OpenFOAM Foundation
+    Copyright (C) 2019-2021 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
+(
+    const dictionary& dict,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su
+)
+{
+    const word modelType(dict.get<word>("XiGModel"));
+
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
+
+    auto* ctorPtr = dictionaryConstructorTable(modelType);
+
+    if (!ctorPtr)
+    {
+        FatalIOErrorInLookup
+        (
+            dict,
+            "XiGModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
+    }
+
+    return autoPtr<XiGModel>(ctorPtr(dict, thermo, turbulence, Su));
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/instabilityG/instabilityG.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "instabilityG.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiGModels
+{
+    defineTypeNameAndDebug(instabilityG, 0);
+    addToRunTimeSelectionTable(XiGModel, instabilityG, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiGModels::instabilityG::instabilityG
+(
+    const dictionary& XiGProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su
+)
+:
+    XiGModel(XiGProperties, thermo, turbulence, Su),
+    GIn_("GIn", dimless/dimTime, XiGModelCoeffs_),
+    lambdaIn_("lambdaIn", dimLength, XiGModelCoeffs_),
+    XiGModel_(XiGModel::New(XiGModelCoeffs_, thermo, turbulence, Su))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiGModels::instabilityG::~instabilityG()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField> Foam::XiGModels::instabilityG::G() const
+{
+    volScalarField turbXiG(XiGModel_->G());
+    return (GIn_*GIn_/(GIn_ + turbXiG) + turbXiG);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::XiGModels::instabilityG::Db() const
+{
+    const objectRegistry& db = Su_.db();
+    const volScalarField& Xi = db.lookupObject<volScalarField>("Xi");
+    const volScalarField& rho = db.lookupObject<volScalarField>("rho");
+    const volScalarField& mgb = db.lookupObject<volScalarField>("mgb");
+
+    return XiGModel_->Db()
+        + rho*Su_*(Xi - 1.0)*mgb*(0.5*lambdaIn_)/(mgb + 1.0/lambdaIn_);
+}
+
+
+bool Foam::XiGModels::instabilityG::read(const dictionary& XiGProperties)
+{
+    XiGModel::read(XiGProperties);
+
+    XiGModelCoeffs_.readEntry("GIn", GIn_);
+    XiGModelCoeffs_.readEntry("lambdaIn", lambdaIn_);
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/instabilityG/instabilityG.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2012 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/>.
+
+Class
+    Foam::XiGModels::instabilityG
+
+Description
+    Flame-surface instabilityG flame-wrinkling generation rate coefficient model
+    used in \link XiModel.H \endlink.
+
+    See Technical Report SH/RE/01R for details on the PDR modelling.
+
+SourceFiles
+    instabilityG.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef instabilityG_H
+#define instabilityG_H
+
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiGModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class instabilityG Declaration
+\*---------------------------------------------------------------------------*/
+
+class instabilityG
+:
+    public XiGModel
+{
+    // Private data
+
+        //- Flame instabilityG wrinkling generation rate coefficient
+        dimensionedScalar GIn_;
+
+        //- InstabilityG length-scale
+        dimensionedScalar lambdaIn_;
+
+        //- Xi generation rate model due to all other processes
+        autoPtr<XiGModel> XiGModel_;
+
+
+    // Private Member Functions
+
+        //- No copy construct
+        instabilityG(const instabilityG&) = delete;
+
+        //- No copy assignment
+        void operator=(const instabilityG&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("instabilityG");
+
+
+    // Constructors
+
+        //- Construct from components
+        instabilityG
+        (
+            const dictionary& XiGProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su
+        );
+
+
+    //- Destructor
+    virtual ~instabilityG();
+
+
+    // Member Functions
+
+        //- Return the flame-wrinkling generation rate
+        virtual tmp<volScalarField> G() const;
+
+        //- Return the flame diffusivity
+        virtual tmp<volScalarField> Db() const;
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiGProperties);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace XiGModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModel.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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "XiModel.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(XiModel, 0);
+    defineRunTimeSelectionTable(XiModel, dictionary);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiModel::XiModel
+(
+    const dictionary& XiProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su,
+    const volScalarField& rho,
+    const volScalarField& b,
+    const surfaceScalarField& phi
+)
+:
+    XiModelCoeffs_
+    (
+        XiProperties.subDict
+        (
+            XiProperties.get<word>("XiModel") + "Coeffs"
+        )
+    ),
+    thermo_(thermo),
+    turbulence_(turbulence),
+    Su_(Su),
+    rho_(rho),
+    b_(b),
+    phi_(phi),
+    Xi_
+    (
+        IOobject
+        (
+            "Xi",
+            b.time().timeName(),
+            b.db(),
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        b.mesh()
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiModel::~XiModel()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::XiModel::read(const dictionary& XiProperties)
+{
+    XiModelCoeffs_ = XiProperties.optionalSubDict(type() + "Coeffs");
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModel.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+Class
+    Foam::XiModel
+
+Description
+    Base-class for all Xi models used by the b-Xi combustion model.
+    See Technical Report SH/RE/01R for details on the PDR modelling.
+
+    Xi is given through an algebraic expression (\link algebraic.H \endlink),
+    by solving a transport equation (\link transport.H \endlink) or a
+    fixed value (\link fixed.H \endlink).
+
+    See report TR/HGW/10 for details on the Weller two equations model.
+
+    In the algebraic and transport methods \f$\Xi_{eq}\f$ is calculated in
+    similar way. In the algebraic approach, \f$\Xi_{eq}\f$ is the value used in
+    the \f$ b \f$ transport equation.
+
+    \f$\Xi_{eq}\f$ is calculated as follows:
+
+    \f$\Xi_{eq} = 1 + (1 + 2\Xi_{coeff}(0.5 - \dwea{b}))(\Xi^* - 1)\f$
+
+    where:
+
+        \f$ \dwea{b} \f$ is the regress variable.
+
+        \f$ \Xi_{coeff} \f$ is a model constant.
+
+        \f$ \Xi^* \f$ is the total equilibrium wrinkling combining the effects
+        of the flame inestability and turbulence interaction and is given by
+
+        \f[
+            \Xi^* = \frac {R}{R - G_\eta - G_{in}}
+        \f]
+
+    where:
+
+        \f$ G_\eta \f$ is the generation rate of wrinkling due to turbulence
+        interaction.
+
+        \f$ G_{in} = \kappa \rho_{u}/\rho_{b} \f$ is the generation
+         rate due to the flame inestability.
+
+    By adding the removal rates of the two effects:
+
+        \f[
+            R = G_\eta \frac{\Xi_{\eta_{eq}}}{\Xi_{\eta_{eq}} - 1}
+              + G_{in} \frac{\Xi_{{in}_{eq}}}{\Xi_{{in}_{eq}} - 1}
+        \f]
+
+    where:
+
+        \f$ R \f$ is the total removal.
+
+        \f$ G_\eta \f$ is a model constant.
+
+        \f$ \Xi_{\eta_{eq}} \f$ is the flame wrinkling due to turbulence.
+
+        \f$ \Xi_{{in}_{eq}} \f$ is the equilibrium level of the flame wrinkling
+        generated by inestability. It is a constant (default 2.5).
+
+
+SourceFiles
+    XiModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef XiModel_H
+#define XiModel_H
+
+#include "IOdictionary.H"
+#include "psiuReactionThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "multivariateSurfaceInterpolationScheme.H"
+#include "fvcDiv.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class XiModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class XiModel
+{
+
+protected:
+
+    // Protected data
+
+        dictionary XiModelCoeffs_;
+
+        const psiuReactionThermo& thermo_;
+        const compressible::RASModel& turbulence_;
+        const volScalarField& Su_;
+        const volScalarField& rho_;
+        const volScalarField& b_;
+        const surfaceScalarField& phi_;
+
+        //- Flame wrinkling field
+        volScalarField Xi_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- No copy construct
+        XiModel(const XiModel&) = delete;
+
+        //- No copy assignment
+        void operator=(const XiModel&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("XiModel");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            XiModel,
+            dictionary,
+            (
+                const dictionary& XiProperties,
+                const psiuReactionThermo& thermo,
+                const compressible::RASModel& turbulence,
+                const volScalarField& Su,
+                const volScalarField& rho,
+                const volScalarField& b,
+                const surfaceScalarField& phi
+            ),
+            (
+                XiProperties,
+                thermo,
+                turbulence,
+                Su,
+                rho,
+                b,
+                phi
+            )
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected Xi model
+        static autoPtr<XiModel> New
+        (
+            const dictionary& XiProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su,
+            const volScalarField& rho,
+            const volScalarField& b,
+            const surfaceScalarField& phi
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        XiModel
+        (
+            const dictionary& XiProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su,
+            const volScalarField& rho,
+            const volScalarField& b,
+            const surfaceScalarField& phi
+        );
+
+
+    //- Destructor
+    virtual ~XiModel();
+
+
+    // Member Functions
+
+        //- Return the flame-wrinkling Xi
+        virtual const volScalarField& Xi() const
+        {
+            return Xi_;
+        }
+
+        //- Return the flame diffusivity
+        virtual tmp<volScalarField> Db() const
+        {
+            return turbulence_.muEff();
+        }
+
+        //- Add Xi to the multivariateSurfaceInterpolationScheme table
+        //  if required
+        virtual void addXi
+        (
+            multivariateSurfaceInterpolationScheme<scalar>::fieldTable&
+        )
+        {}
+
+        //- Correct the flame-wrinkling Xi
+        virtual void correct() = 0;
+
+        //- Correct the flame-wrinkling Xi using the given convection scheme
+        virtual void correct(const fv::convectionScheme<scalar>&)
+        {
+            correct();
+        }
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiProperties) = 0;
+
+        //- Write fields related to Xi model
+        virtual void writeFields() = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModelNew.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 OpenFOAM Foundation
+    Copyright (C) 2019-2021 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "XiModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
+(
+    const dictionary& dict,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su,
+    const volScalarField& rho,
+    const volScalarField& b,
+    const surfaceScalarField& phi
+)
+{
+    const word modelType(dict.get<word>("XiModel"));
+
+    Info<< "Selecting flame-wrinkling model " << modelType << endl;
+
+    auto* ctorPtr = dictionaryConstructorTable(modelType);
+
+    if (!ctorPtr)
+    {
+        FatalIOErrorInLookup
+        (
+            dict,
+            "XiModel",
+            modelType,
+            *dictionaryConstructorTablePtr_
+        ) << exit(FatalIOError);
+    }
+
+    return autoPtr<XiModel>
+    (
+        ctorPtr(dict, thermo, turbulence, Su, rho, b, phi)
+    );
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/algebraic/algebraic.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "algebraic.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+    defineTypeNameAndDebug(algebraic, 0);
+    addToRunTimeSelectionTable(XiModel, algebraic, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiModels::algebraic::algebraic
+(
+    const dictionary& XiProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su,
+    const volScalarField& rho,
+    const volScalarField& b,
+    const surfaceScalarField& phi
+)
+:
+    XiModel(XiProperties, thermo, turbulence, Su, rho, b, phi),
+    XiShapeCoef(XiModelCoeffs_.get<scalar>("XiShapeCoef")),
+    XiEqModel_(XiEqModel::New(XiProperties, thermo, turbulence, Su)),
+    XiGModel_(XiGModel::New(XiProperties, thermo, turbulence, Su))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiModels::algebraic::~algebraic()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField> Foam::XiModels::algebraic::Db() const
+{
+    return XiGModel_->Db();
+}
+
+
+void Foam::XiModels::algebraic::correct()
+{
+    volScalarField XiEqEta(XiEqModel_->XiEq());
+    volScalarField GEta(XiGModel_->G());
+
+    volScalarField R(GEta*XiEqEta/(XiEqEta - 0.999));
+
+    volScalarField XiEqStar(R/(R - GEta));
+
+    Xi_ == 1.0 + (1.0 + (2*XiShapeCoef)*(0.5 - b_))*(XiEqStar - 1.0);
+}
+
+
+bool Foam::XiModels::algebraic::read(const dictionary& XiProperties)
+{
+    XiModel::read(XiProperties);
+
+    XiModelCoeffs_.readEntry("XiShapeCoef", XiShapeCoef);
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/algebraic/algebraic.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2012 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/>.
+
+Class
+    Foam::XiModels::algebraic
+
+Description
+    Simple algebraic model for Xi based on Gulders correlation
+    with a linear correction function to give a plausible profile for Xi.
+    See report TR/HGW/10 for details on the Weller two equations model.
+    See \link XiModel.H \endlink for more details on flame wrinkling modelling.
+
+SourceFiles
+    algebraic.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef algebraic_H
+#define algebraic_H
+
+#include "XiModel.H"
+#include "XiEqModel.H"
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class algebraic Declaration
+\*---------------------------------------------------------------------------*/
+
+class algebraic
+:
+    public XiModel
+{
+    // Private data
+
+        scalar XiShapeCoef;
+
+        autoPtr<XiEqModel> XiEqModel_;
+        autoPtr<XiGModel> XiGModel_;
+
+
+    // Private Member Functions
+
+        //- No copy construct
+        algebraic(const algebraic&) = delete;
+
+        //- No copy assignment
+        void operator=(const algebraic&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("algebraic");
+
+
+    // Constructors
+
+        //- Construct from components
+        algebraic
+        (
+            const dictionary& XiProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su,
+            const volScalarField& rho,
+            const volScalarField& b,
+            const surfaceScalarField& phi
+        );
+
+
+    //- Destructor
+    virtual ~algebraic();
+
+
+    // Member Functions
+
+        //- Return the flame diffusivity
+        virtual tmp<volScalarField> Db() const;
+
+        //- Correct the flame-wrinkling Xi
+        virtual void correct();
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiProperties);
+
+        //- Write fields of the XiEq model
+        virtual void writeFields()
+        {
+            XiEqModel_().writeFields();
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace XiModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/fixed/fixed.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fixed.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+    defineTypeNameAndDebug(fixed, 0);
+    addToRunTimeSelectionTable(XiModel, fixed, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiModels::fixed::fixed
+(
+    const dictionary& XiProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su,
+    const volScalarField& rho,
+    const volScalarField& b,
+    const surfaceScalarField& phi
+)
+:
+    XiModel(XiProperties, thermo, turbulence, Su, rho, b, phi)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiModels::fixed::~fixed()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::XiModels::fixed::read(const dictionary& XiProperties)
+{
+    return XiModel::read(XiProperties);
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/fixed/fixed.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2012 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/>.
+
+Class
+    Foam::XiModels::fixed
+
+Description
+    Fixed value model for Xi. See \link XiModel.H \endlink for more details
+    on flame wrinkling modelling.
+
+SourceFiles
+    fixed.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fixed_H
+#define fixed_H
+
+#include "XiModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class fixed Declaration
+\*---------------------------------------------------------------------------*/
+
+class fixed
+:
+    public XiModel
+{
+    // Private Member Functions
+
+        //- No copy construct
+        fixed(const fixed&) = delete;
+
+        //- No copy assignment
+        void operator=(const fixed&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fixed");
+
+
+    // Constructors
+
+        //- Construct from components
+        fixed
+        (
+            const dictionary& XiProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su,
+            const volScalarField& rho,
+            const volScalarField& b,
+            const surfaceScalarField& phi
+        );
+
+
+    //- Destructor
+    virtual ~fixed();
+
+
+    // Member Functions
+
+        //- Correct the flame-wrinkling Xi
+        virtual void correct()
+        {}
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiProperties);
+
+        //- Write fields of the XiEq model
+        virtual void writeFields()
+        {}
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace XiModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/transport/transport.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "transport.H"
+#include "surfaceInterpolate.H"
+#include "fvmDdt.H"
+#include "fvcLaplacian.H"
+#include "fvmDiv.H"
+#include "fvmSup.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+    defineTypeNameAndDebug(transport, 0);
+    addToRunTimeSelectionTable(XiModel, transport, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::XiModels::transport::transport
+(
+    const dictionary& XiProperties,
+    const psiuReactionThermo& thermo,
+    const compressible::RASModel& turbulence,
+    const volScalarField& Su,
+    const volScalarField& rho,
+    const volScalarField& b,
+    const surfaceScalarField& phi
+)
+:
+    XiModel(XiProperties, thermo, turbulence, Su, rho, b, phi),
+    XiShapeCoef(XiModelCoeffs_.get<scalar>("XiShapeCoef")),
+    XiEqModel_(XiEqModel::New(XiProperties, thermo, turbulence, Su)),
+    XiGModel_(XiGModel::New(XiProperties, thermo, turbulence, Su))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::XiModels::transport::~transport()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField> Foam::XiModels::transport::Db() const
+{
+    return XiGModel_->Db();
+}
+
+
+void Foam::XiModels::transport::correct
+(
+    const fv::convectionScheme<scalar>& mvConvection
+)
+{
+    volScalarField XiEqEta(XiEqModel_->XiEq());
+    volScalarField GEta(XiGModel_->G());
+
+    volScalarField R(GEta*XiEqEta/(XiEqEta - 0.999));
+
+    volScalarField XiEqStar(R/(R - GEta));
+
+    volScalarField XiEq
+    (
+        1.0 + (1.0 + (2*XiShapeCoef)*(0.5 - b_))*(XiEqStar - 1.0)
+    );
+
+    volScalarField G(R*(XiEq - 1.0)/XiEq);
+
+    const objectRegistry& db = b_.db();
+    const volScalarField& betav = db.lookupObject<volScalarField>("betav");
+    const volScalarField& mgb = db.lookupObject<volScalarField>("mgb");
+    const surfaceScalarField& phiSt =
+        db.lookupObject<surfaceScalarField>("phiSt");
+    const volScalarField& Db = db.lookupObject<volScalarField>("Db");
+    const surfaceScalarField& nf = db.lookupObject<surfaceScalarField>("nf");
+
+    surfaceScalarField phiXi
+    (
+        "phiXi",
+        phiSt
+      + (
+          - fvc::interpolate(fvc::laplacian(Db, b_)/mgb)*nf
+          + fvc::interpolate(rho_)*fvc::interpolate(Su_*(1.0/Xi_ - Xi_))*nf
+        )
+    );
+
+    solve
+    (
+        betav*fvm::ddt(rho_, Xi_)
+      + mvConvection.fvmDiv(phi_, Xi_)
+      + fvm::div(phiXi, Xi_)
+      - fvm::Sp(fvc::div(phiXi), Xi_)
+     ==
+        betav*rho_*R
+      - fvm::Sp(betav*rho_*(R - G), Xi_)
+    );
+
+    // Correct boundedness of Xi
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~
+    Xi_.max(1.0);
+    Xi_ = min(Xi_, 2.0*XiEq);
+}
+
+
+bool Foam::XiModels::transport::read(const dictionary& XiProperties)
+{
+    XiModel::read(XiProperties);
+
+    XiModelCoeffs_.readEntry("XiShapeCoef", XiShapeCoef);
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/XiModels/transport/transport.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2015 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/>.
+
+Class
+    Foam::XiModels::transport
+
+Description
+    Simple transport model for Xi based on Gulders correlation
+    with a linear correction function to give a plausible profile for Xi.
+    See report TR/HGW/10 for details on the Weller two equations model.
+    See \link XiModel.H \endlink for more details on flame wrinkling modelling.
+
+SourceFiles
+    transport.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef transport_H
+#define transport_H
+
+#include "XiModel.H"
+#include "XiEqModel.H"
+#include "XiGModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace XiModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class transport Declaration
+\*---------------------------------------------------------------------------*/
+
+class transport
+:
+    public XiModel
+{
+    // Private data
+
+        scalar XiShapeCoef;
+
+        autoPtr<XiEqModel> XiEqModel_;
+        autoPtr<XiGModel> XiGModel_;
+
+
+    // Private Member Functions
+
+        //- No copy construct
+        transport(const transport&) = delete;
+
+        //- No copy assignment
+        void operator=(const transport&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("transport");
+
+
+    // Constructors
+
+        //- Construct from components
+        transport
+        (
+            const dictionary& XiProperties,
+            const psiuReactionThermo& thermo,
+            const compressible::RASModel& turbulence,
+            const volScalarField& Su,
+            const volScalarField& rho,
+            const volScalarField& b,
+            const surfaceScalarField& phi
+        );
+
+
+    //- Destructor
+    virtual ~transport();
+
+
+    // Member Functions
+
+        //- Return the flame diffusivity
+        virtual tmp<volScalarField> Db() const;
+
+        //- Add Xi to the multivariateSurfaceInterpolationScheme table
+        virtual void addXi
+        (
+            multivariateSurfaceInterpolationScheme<scalar>::fieldTable& fields
+        )
+        {
+            fields.add(Xi_);
+        }
+
+        //- Correct the flame-wrinkling Xi
+        virtual void correct()
+        {
+            NotImplemented;
+        }
+
+        //- Correct the flame-wrinkling Xi using the given convection scheme
+        virtual void correct(const fv::convectionScheme<scalar>& mvConvection);
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& XiProperties);
+
+        //- Write fields of the XiEq model
+        virtual void writeFields()
+        {
+            XiEqModel_().writeFields();
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace XiModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/PDRFoam/bEqn.H

+tmp<fv::convectionScheme<scalar>> mvConvection
+(
+    fv::convectionScheme<scalar>::New
+    (
+        mesh,
+        fields,
+        phi,
+        mesh.divScheme("div(phi,ft_b_ha_hau)")
+    )
+);
+
+volScalarField Db("Db", turbulence->muEff());
+
+if (ign.ignited())
+{
+    // Calculate the unstrained laminar flame speed
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Su = unstrainedLaminarFlameSpeed()();
+
+    const volScalarField& Xi = flameWrinkling->Xi();
+
+    // progress variable
+    // ~~~~~~~~~~~~~~~~~
+    volScalarField c("c", 1.0 - b);
+
+    // Unburnt gas density
+    // ~~~~~~~~~~~~~~~~~~~
+    volScalarField rhou(thermo.rhou());
+
+    // Calculate flame normal etc.
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    //volVectorField n(fvc::grad(b));
+    volVectorField n(fvc::reconstruct(fvc::snGrad(b)*mesh.magSf()));
+
+    volScalarField mgb("mgb", mag(n));
+
+    dimensionedScalar dMgb("dMgb", mgb.dimensions(), SMALL);
+
+    {
+        volScalarField bc(b*c);
+
+        dMgb += 1.0e-3*
+            (bc*mgb)().weightedAverage(mesh.V())
+           /(bc.weightedAverage(mesh.V()) + 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("nf", mesh.Sf() & nfVec);
+    n /= mgb;
+
+    #include "StCorr.H"
+
+    // Calculate turbulent flame speed flux
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    surfaceScalarField phiSt("phiSt", fvc::interpolate(rhou*StCorr*St)*nf);
+
+    #include "StCourantNo.H"
+
+    Db = flameWrinkling->Db();
+
+    // Create b equation
+    // ~~~~~~~~~~~~~~~~~
+    fvScalarMatrix bEqn
+    (
+        betav*fvm::ddt(rho, b)
+      + mvConvection->fvmDiv(phi, b)
+      + fvm::div(phiSt, b)
+      - fvm::Sp(fvc::div(phiSt), b)
+      - fvm::laplacian(Db, b)
+     ==
+        betav*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;
+
+    if (composition.contains("ft"))
+    {
+        volScalarField& ft = composition.Y("ft");
+
+        Info<< "Combustion progress = "
+            << 100*(1.0 - b)().weightedAverage(mesh.V()*ft).value() << "%"
+            << endl;
+    }
+    else
+    {
+        Info<< "Combustion progress = "
+            << 100*(1.0 - b)().weightedAverage(mesh.V()).value() << "%"
+            << endl;
+    }
+
+    // Correct the flame-wrinkling
+    flameWrinkling->correct(mvConvection);
+
+    St = Xi*Su;
+}

applications/solvers/combustion/PDRFoam/createFieldRefs.H

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

applications/solvers/combustion/PDRFoam/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::RASModel> turbulence
+(
+    compressible::New<compressible::RASModel>
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+
+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
+);
+
+Info<< "Reading field betav\n" << endl;
+volScalarField betav
+(
+    IOobject
+    (
+        "betav",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field Lobs\n" << endl;
+volScalarField Lobs
+(
+    IOobject
+    (
+        "Lobs",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field CT\n" << endl;
+volSymmTensorField CT
+(
+    IOobject
+    (
+        "CT",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field Nv\n" << endl;
+volScalarField Nv
+(
+    IOobject
+    (
+        "Nv",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field nsv\n" << endl;
+volSymmTensorField nsv
+(
+    IOobject
+    (
+        "nsv",
+        mesh.facesInstance(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+IOdictionary PDRProperties
+(
+    IOobject
+    (
+        "PDRProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
+
+//- Create the drag model
+autoPtr<PDRDragModel> drag = PDRDragModel::New
+(
+    PDRProperties,
+    *turbulence,
+    rho,
+    U,
+    phi
+);
+
+//- Create the flame-wrinkling model
+autoPtr<XiModel> flameWrinkling = XiModel::New
+(
+    PDRProperties,
+    thermo,
+    *turbulence,
+    Su,
+    rho,
+    b,
+    phi
+);
+
+Info<< "Calculating turbulent flame speed field St\n" << endl;
+volScalarField St
+(
+    IOobject
+    (
+        "St",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    flameWrinkling->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());
+flameWrinkling->addXi(fields);
+
+#include "createDpdt.H"
+
+#include "createK.H"
+
+#include "createMRF.H"
+#include "createFvOptions.H"

applications/solvers/combustion/PDRFoam/ftEqn.H

+if (composition.contains("ft"))
+{
+    volScalarField& ft = composition.Y("ft");
+
+    solve
+    (
+        betav*fvm::ddt(rho, ft)
+      + mvConvection->fvmDiv(phi, ft)
+      - fvm::laplacian(Db, ft)
+    );
+}

applications/solvers/combustion/PDRFoam/laminarFlameSpeed/SCOPE/SCOPELaminarFlameSpeed.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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "IFstream.H"
+#include "SCOPELaminarFlameSpeed.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace laminarFlameSpeedModels
+{
+    defineTypeNameAndDebug(SCOPE, 0);
+
+    addToRunTimeSelectionTable
+    (
+        laminarFlameSpeed,
+        SCOPE,
+        dictionary
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::laminarFlameSpeedModels::SCOPE::polynomial::polynomial
+(
+    const dictionary& polyDict
+)
+:
+    FixedList<scalar, 7>(polyDict.lookup("coefficients")),
+    ll(polyDict.get<scalar>("lowerLimit")),
+    ul(polyDict.get<scalar>("upperLimit")),
+    llv(polyPhi(ll, *this)),
+    ulv(polyPhi(ul, *this)),
+    lu(0)
+{}
+
+
+Foam::laminarFlameSpeedModels::SCOPE::SCOPE
+(
+    const dictionary& dict,
+    const psiuReactionThermo& ct
+)
+:
+    laminarFlameSpeed(dict, ct),
+
+    coeffsDict_
+    (
+        dictionary
+        (
+            IFstream
+            (
+                dict.get<fileName>("fuelFile")
+            )()
+        ).optionalSubDict(typeName + "Coeffs")
+    ),
+    LFL_
+    (
+        coeffsDict_.getCompat<scalar>
+        (
+            "lowerFlammabilityLimit",
+            {{"lowerFlamabilityLimit", 1712}}
+        )
+    ),
+    UFL_
+    (
+        coeffsDict_.getCompat<scalar>
+        (
+            "upperFlammabilityLimit",
+            {{"upperFlamabilityLimit", 1712}}
+        )
+    ),
+    SuPolyL_(coeffsDict_.subDict("lowerSuPolynomial")),
+    SuPolyU_(coeffsDict_.subDict("upperSuPolynomial")),
+    Texp_(coeffsDict_.get<scalar>("Texp")),
+    pexp_(coeffsDict_.get<scalar>("pexp")),
+    MaPolyL_(coeffsDict_.subDict("lowerMaPolynomial")),
+    MaPolyU_(coeffsDict_.subDict("upperMaPolynomial"))
+{
+    SuPolyL_.ll = max(SuPolyL_.ll, LFL_) + SMALL;
+    SuPolyU_.ul = min(SuPolyU_.ul, UFL_) - SMALL;
+
+    SuPolyL_.lu = 0.5*(SuPolyL_.ul + SuPolyU_.ll);
+    SuPolyU_.lu = SuPolyL_.lu - SMALL;
+
+    MaPolyL_.lu = 0.5*(MaPolyL_.ul + MaPolyU_.ll);
+    MaPolyU_.lu = MaPolyL_.lu - SMALL;
+
+    if (debug)
+    {
+        Info<< "phi     Su  (T = Tref, p = pref)" << endl;
+        label n = 200;
+        for (int i=0; i<n; i++)
+        {
+            scalar phi = (2.0*i)/n;
+            Info<< phi << token::TAB << SuRef(phi) << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::laminarFlameSpeedModels::SCOPE::~SCOPE()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::polyPhi
+(
+    scalar phi,
+    const polynomial& a
+)
+{
+    scalar x = phi - 1.0;
+
+    return
+        a[0]
+       *(
+           scalar(1)
+         + x*(a[1] + x*(a[2] + x*(a[3] + x*(a[4] + x*(a[5] + x*a[6])))))
+        );
+}
+
+
+inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::SuRef
+(
+    scalar phi
+) const
+{
+    if (phi < LFL_ || phi > UFL_)
+    {
+        // Return 0 beyond the flammability limits
+        return scalar(0);
+    }
+    else if (phi < SuPolyL_.ll)
+    {
+        // Use linear interpolation between the low end of the
+        // lower polynomial and the lower flammability limit
+        return SuPolyL_.llv*(phi - LFL_)/(SuPolyL_.ll - LFL_);
+    }
+    else if (phi > SuPolyU_.ul)
+    {
+        // Use linear interpolation between the upper end of the
+        // upper polynomial and the upper flammability limit
+        return SuPolyU_.ulv*(UFL_ - phi)/(UFL_ - SuPolyU_.ul);
+    }
+    else if (phi < SuPolyL_.lu)
+    {
+        // Evaluate the lower polynomial
+        return polyPhi(phi, SuPolyL_);
+    }
+    else if (phi > SuPolyU_.lu)
+    {
+        // Evaluate the upper polynomial
+        return polyPhi(phi, SuPolyU_);
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "phi = " << phi
+            << " cannot be handled by SCOPE function with the "
+               "given coefficients"
+            << exit(FatalError);
+
+        return scalar(0);
+    }
+}
+
+
+inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::Ma
+(
+    scalar phi
+) const
+{
+    if (phi < MaPolyL_.ll)
+    {
+        // Beyond the lower limit assume Ma is constant
+        return MaPolyL_.llv;
+    }
+    else if (phi > MaPolyU_.ul)
+    {
+        // Beyond the upper limit assume Ma is constant
+        return MaPolyU_.ulv;
+    }
+    else if (phi < SuPolyL_.lu)
+    {
+        // Evaluate the lower polynomial
+        return polyPhi(phi, MaPolyL_);
+    }
+    else if (phi > SuPolyU_.lu)
+    {
+        // Evaluate the upper polynomial
+        return polyPhi(phi, MaPolyU_);
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "phi = " << phi
+            << " cannot be handled by SCOPE function with the "
+               "given coefficients"
+            << exit(FatalError);
+
+        return scalar(0);
+    }
+}
+
+
+inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::Su0pTphi
+(
+    scalar p,
+    scalar Tu,
+    scalar phi
+) const
+{
+    static const scalar Tref = 300.0;
+    static const scalar pRef = 1.013e5;
+
+    return SuRef(phi)*pow((Tu/Tref), Texp_)*pow((p/pRef), pexp_);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::laminarFlameSpeedModels::SCOPE::Su0pTphi
+(
+    const volScalarField& p,
+    const volScalarField& Tu,
+    scalar phi
+) const
+{
+    tmp<volScalarField> tSu0
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "Su0",
+                p.time().timeName(),
+                p.db(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            p.mesh(),
+            dimensionedScalar(dimVelocity, Zero)
+        )
+    );
+
+    volScalarField& Su0 = tSu0.ref();
+
+    forAll(Su0, celli)
+    {
+        Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi);
+    }
+
+    volScalarField::Boundary& Su0Bf = Su0.boundaryFieldRef();
+
+    forAll(Su0Bf, patchi)
+    {
+        scalarField& Su0p = Su0Bf[patchi];
+        const scalarField& pp = p.boundaryField()[patchi];
+        const scalarField& Tup = Tu.boundaryField()[patchi];
+
+        forAll(Su0p, facei)
+        {
+            Su0p[facei] = Su0pTphi(pp[facei], Tup[facei], phi);
+        }
+    }
+
+    return tSu0;
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::laminarFlameSpeedModels::SCOPE::Su0pTphi
+(
+    const volScalarField& p,
+    const volScalarField& Tu,
+    const volScalarField& phi
+) const
+{
+    tmp<volScalarField> tSu0
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "Su0",
+                p.time().timeName(),
+                p.db(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            p.mesh(),
+            dimensionedScalar(dimVelocity, Zero)
+        )
+    );
+
+    volScalarField& Su0 = tSu0.ref();
+
+    forAll(Su0, celli)
+    {
+        Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi[celli]);
+    }
+
+    volScalarField::Boundary& Su0Bf = Su0.boundaryFieldRef();
+
+    forAll(Su0Bf, patchi)
+    {
+        scalarField& Su0p = Su0Bf[patchi];
+        const scalarField& pp = p.boundaryField()[patchi];
+        const scalarField& Tup = Tu.boundaryField()[patchi];
+        const scalarField& phip = phi.boundaryField()[patchi];
+
+        forAll(Su0p, facei)
+        {
+            Su0p[facei] =
+                Su0pTphi
+                (
+                    pp[facei],
+                    Tup[facei],
+                    phip[facei]
+                );
+        }
+    }
+
+    return tSu0;
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::laminarFlameSpeedModels::SCOPE::Ma
+(
+    const volScalarField& phi
+) const
+{
+    tmp<volScalarField> tMa
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "Ma",
+                phi.time().timeName(),
+                phi.db(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            phi.mesh(),
+            dimensionedScalar(dimless, Zero)
+        )
+    );
+
+    volScalarField& ma = tMa.ref();
+
+    forAll(ma, celli)
+    {
+        ma[celli] = Ma(phi[celli]);
+    }
+
+    volScalarField::Boundary& maBf = ma.boundaryFieldRef();
+
+    forAll(maBf, patchi)
+    {
+        scalarField& map = maBf[patchi];
+        const scalarField& phip = phi.boundaryField()[patchi];
+
+        forAll(map, facei)
+        {
+            map[facei] = Ma(phip[facei]);
+        }
+    }
+
+    return tMa;
+}
+
+
+Foam::tmp<Foam::volScalarField>
+Foam::laminarFlameSpeedModels::SCOPE::Ma() const
+{
+    if (psiuReactionThermo_.composition().contains("ft"))
+    {
+        const volScalarField& ft = psiuReactionThermo_.composition().Y("ft");
+
+        return Ma
+        (
+            dimensionedScalar
+            (
+                "stoichiometricAirFuelMassRatio", dimless, psiuReactionThermo_
+            )*ft/(scalar(1) - ft)
+        );
+    }
+    else
+    {
+        const fvMesh& mesh = psiuReactionThermo_.p().mesh();
+
+        return tmp<volScalarField>
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "Ma",
+                    mesh.time().timeName(),
+                    mesh,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                mesh,
+                dimensionedScalar("Ma", dimless, Ma(equivalenceRatio_))
+            )
+        );
+    }
+}
+
+
+Foam::tmp<Foam::volScalarField>
+Foam::laminarFlameSpeedModels::SCOPE::operator()() const
+{
+    if (psiuReactionThermo_.composition().contains("ft"))
+    {
+        const volScalarField& ft = psiuReactionThermo_.composition().Y("ft");
+
+        return Su0pTphi
+        (
+            psiuReactionThermo_.p(),
+            psiuReactionThermo_.Tu(),
+            dimensionedScalar
+            (
+                "stoichiometricAirFuelMassRatio", dimless, psiuReactionThermo_
+            )*ft/(scalar(1) - ft)
+        );
+    }
+    else
+    {
+        return Su0pTphi
+        (
+            psiuReactionThermo_.p(),
+            psiuReactionThermo_.Tu(),
+            equivalenceRatio_
+        );
+    }
+}
+
+
+// ************************************************************************* //