mfEqn indentation and jlc, vlc, nlc AUTO_WRITE => NO_WRITE

.gitlab-ci.yml

@@ -1,23 +1,9 @@
+before_script:
+  - "[[ -d ../ThirdParty-4.x ]] || git clone https://github.com/OpenFOAM/ThirdParty-4.x.git ../ThirdParty-4.x"
+  - source etc/bashrc
+  - rm -rf platforms
+  - wclean all
+
 allmake:
-  image: park0d/of4builder
-  tags:
-    - openfoam4
-  before_script:
-    - "[[ -d ../ThirdParty-4.x ]] || git clone https://github.com/OpenFOAM/ThirdParty-4.x.git ../ThirdParty-4.x"
-    - source etc/bashrc
-    - rm -rf platforms
-    - wclean all
   script:
     - ./Allwmake -j
-  artifacts:
-    paths:
-      - ./
-
-cantera:
-    image: park0d/of4builder
-    tags:
-        - openfoam4
-    script:
-        - whereis libcantera
-    
-  

applications/solvers/combustion/SLFMFoam/AMC/AMC.C

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "AMC.H"
+
+#include "error.H"
+
+// * * * * * * * * * * * * * Functions * * * * * * * * * * * * //
+
+//Amplitude Mapping Closure (from KIVA)
+Foam::tmp<Foam::scalarField> Foam::CMC::AMC(const scalarField& eta)
+{
+    tmp<scalarField> tRes(new scalarField(eta.size(), 0.0));
+
+    scalarField& Res = tRes.ref();
+
+    for(label i=0 ; i<eta.size() ; i++)
+    {
+        Res[i] = AMC(eta[i]);
+    }
+
+    return tRes;
+}
+
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/AMC/AMC.H

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Function
+    Foam::CMC::AMC
+
+Description
+
+SourceFiles
+    AMC.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef AMC_H
+#define AMC_H
+
+#include "tmp.H"
+#include "scalarField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace CMC
+{
+
+/*---------------------------------------------------------------------------*\
+                         Function AMC Declaration
+\*---------------------------------------------------------------------------*/
+
+    const scalar pi = 3.141592;
+
+    const scalar spi = Foam::sqrt(pi);
+
+    //Amplitude Mapping Closure (from KIVA)
+    tmp<scalarField> AMC(const scalarField& eta);
+
+
+    //Amplitude Mapping Closure (from KIVA)
+    //Define exp(-2*(erf^-1(2*eta - 1))^2)
+    inline scalar AMC(const scalar eta);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace CMC
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "AMCI.H"
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/AMC/AMCI.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+//Amplitude Mapping Closure (from KIVA)
+//Define exp(-2*(erf^-1(2*eta - 1))^2)
+inline Foam::scalar Foam::CMC::AMC(const scalar eta)
+{
+    const scalar a0 = (2.0*eta - 1.0);
+    scalar a1 = 0.5;
+    scalar slope;
+    scalar da = GREAT;
+
+    while(mag(da) > SMALL)
+    {
+        slope = (2.0/spi)*Foam::exp(-1.0*Foam::pow(a1,2.0));
+        da = (a0 - Foam::erf(a1))/slope;
+        a1 = a1 + da;
+    }
+
+    return Foam::exp(-2.0*Foam::pow(a1,2.0));
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaFunction/BetaFunction.C

@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaFunction.H"
+
+#include "error.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// const scalar Foam::CMC::BetaFunction::staticData();
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::CMC::BetaFunction::_setParameters()
+{
+        scalar gamma = mf_*(1.0 - mf_)/(mfVar_ + SMALL) - 1.0;
+
+        if (gamma < SMALL || (mfVar_)/(mf_*(1 - mf_) + SMALL) < 0.001)
+        {
+            fdelta_ = true;
+        }
+        else
+        {
+            a_ = max(mf_*gamma, 0.0);
+            b_ = max((1.0 - mf_)*gamma, 0.0);
+
+            if(a_ < 1.0)
+            {
+                delta0_ = true;
+            }
+            if(b_ < 1.0)
+            {
+                delta1_ = true;
+            }
+
+            _limitAB();
+        }
+}
+
+
+void Foam::CMC::BetaFunction::_limitAB()
+{
+    scalar fmax = 1.0/(1.0 + (b_ - 1.0)/(a_ - 1.0));
+
+    if(a_ > 500.0)
+    {
+        a_ = 500.0;
+        b_ = (a_ - 1.0 - fmax*(a_ - 2.0))/fmax;
+    }
+    else if(b_ > 500.0)
+    {
+        b_ = 500.0;
+        a_ = (1.0 + fmax*(b_ - 2.0))/(1.0 - fmax);
+    }
+}
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaFunction::BetaFunction(const scalar mf, const scalar mfVar)
+:
+    mf_(mf),
+    mfVar_(mfVar),
+    a_(0.0),
+    b_(0.0),
+    fdelta_(false),
+    delta0_(false),
+    delta1_(false)
+{
+    _setParameters();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaFunction::~BetaFunction()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaFunction/BetaFunction.H

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::BetaFunction
+
+Description
+
+SourceFiles
+    BetaFunctionI.H
+    BetaFunction.C
+    BetaFunctionIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef BetaFunction_H
+#define BetaFunction_H
+
+#include "scalar.H"
+#include "Switch.H"
+#include "scalarField.H"
+#include "tmp.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+namespace CMC
+{
+    class BetaFunction;
+}
+Istream& operator>>(Istream&, CMC::BetaFunction&);
+Ostream& operator<<(Ostream&, const CMC::BetaFunction&);
+
+
+/*---------------------------------------------------------------------------*\
+                         Class BetaFunction Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace CMC
+{
+
+class BetaFunction
+{
+    // Private data
+
+        //- Mean mixture fraction
+        scalar mf_;
+
+        //- Mixture fraction variance
+        scalar mfVar_;
+
+        //- Beta pdf parameter alpha
+        scalar a_;
+
+        //- Beta pdf parameter beta
+        scalar b_;
+
+        //- Flag beta pdf special case: forced-delta function
+        Switch fdelta_;
+
+        //- delta function at pure oxidizer stream
+        Switch delta0_;
+
+        //- delta function at pure fuel stream
+        Switch delta1_;
+
+
+    // Private Member Functions
+
+        //- Calculate alpha and beta and set special case flags
+        void _setParameters();
+
+        //- Limit too large value of beta pdf parameters
+        void _limitAB();
+
+        //- Disallow default bitwise copy construct
+        // BetaFunction(const BetaFunction&);
+
+        //- Disallow default bitwise assignment
+        // void operator=(const BetaFunction&);
+
+
+public:
+
+    // Static data members
+
+        //- Static data staticData
+        // static const scalar staticData;
+
+
+    // Constructors
+
+        //- Construct from components
+        BetaFunction(const scalar mf, const scalar mfVar);
+
+        //- Construct from Istream
+        BetaFunction(Istream&);
+
+        //- Construct as copy
+        // BetaFunction(const BetaFunction&);
+
+
+    //- Destructor
+    ~BetaFunction();
+
+
+    // Member Functions
+
+        tmp<scalarField> etaFunc(const UList<scalar>& eta) const
+        {
+            return pow(eta, a_-1.0)*pow(1.0-eta, b_-1.0);
+        }
+
+        scalar etaFunc(const scalar eta) const
+        {
+            return Foam::pow(eta, a_-1.0)*Foam::pow(1.0-eta, b_-1.0);
+        }
+
+
+        // Access
+
+            Switch fdelta() const {return fdelta_;}
+
+            Switch delta0() const {return delta0_;}
+
+            Switch delta1() const {return delta1_;}
+
+            scalar mf() const {return mf_;}
+
+            scalar mfVar() const {return mfVar_;}
+
+            scalar alpha() const {return a_;}
+
+            scalar beta() const {return b_;}
+
+        // Check
+
+        // Edit
+
+        // Write
+
+
+    // Member Operators
+
+        // void operator=(const BetaFunction&);
+
+
+    // Friend Functions
+
+    // Friend Operators
+
+    // IOstream Operators
+
+        friend Istream& ::Foam::operator>>(Istream&, BetaFunction&);
+        friend Ostream& ::Foam::operator<<(Ostream&, const BetaFunction&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace CMC
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "BetaFunctionI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaFunction/BetaFunctionI.H

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaFunction/BetaFunctionIO.C

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaFunction.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaFunction::BetaFunction(Istream& is)
+{
+    // Check state of Istream
+    is.check("Foam::CMC::BetaFunction::BetaFunction(Foam::Istream&)");
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaFunction&)
+{
+    // Check state of Istream
+    is.check
+    (
+        "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaFunction&)"
+    );
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaFunction&)
+{
+    // Check state of Ostream
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
+        "const Foam::CMC::BetaFunction&)"
+    );
+
+    return os;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaGrid/BetaGrid.C

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaGrid.H"
+
+#include "error.H"
+#include "dictionary.H"
+#include "SubList.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// const scalar Foam::CMC::BetaGrid::staticData();
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaGrid::BetaGrid(const dictionary& dict)
+:
+    etaCut_(dict.lookup("detailedEta")),
+    nSpacings_(dict.lookup("detailedN")),
+    etaSpace_(sum(nSpacings_)+3)
+{
+    // Check for input list size
+    if (etaCut_.size() != nSpacings_.size() + 1)
+    {
+        FatalErrorInFunction
+            << "Number of grid interval points does not match number of grid sizes"
+            << abort(FatalError);
+    }
+
+    // Check for evenness of number of spacings in each interval
+    forAll (nSpacings_, i)
+    {
+        if ((nSpacings_[i] % 2) == 1)
+        {
+            FatalErrorInFunction
+                << "Number of spacings in intervals should be even"
+                << abort(FatalError);
+        }
+    }
+
+    forAll(nSpacings_, i)
+    {
+        const label ns = nSpacings_[i];
+        const labelList::subList prev(nSpacings_, i);
+        const label baseI = sum(prev) + 1;
+
+        const scalar low = etaCut_[i];
+        const scalar upp = etaCut_[i+1];
+        const scalar delta = (upp - low) / scalar(ns);
+
+        for (label j = 0; j < ns; j++)
+        {
+            etaSpace_[baseI+j] = low + delta * j;
+        }
+    }
+    etaSpace_[0] = 0.0;
+    etaSpace_[etaSpace_.size()-2] = etaCut_.last();
+    etaSpace_[etaSpace_.size()-1] = 1.0;
+}
+
+
+Foam::CMC::BetaGrid::BetaGrid(const BetaGrid&)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaGrid::~BetaGrid()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+void Foam::CMC::BetaGrid::operator=(const BetaGrid& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorInFunction
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaGrid/BetaGrid.H

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::BetaGrid
+
+Description
+
+SourceFiles
+    BetaGridI.H
+    BetaGrid.C
+    BetaGridIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef BetaGrid_H
+#define BetaGrid_H
+
+#include "scalarField.H"
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+namespace CMC
+{
+    class BetaGrid;
+}
+class dictionary;
+
+Istream& operator>>(Istream&, CMC::BetaGrid&);
+Ostream& operator<<(Ostream&, const CMC::BetaGrid&);
+
+
+/*---------------------------------------------------------------------------*\
+                         Class BetaGrid Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace CMC
+{
+
+class BetaGrid
+{
+    // Private data
+
+        //- Piecewise uniform interval points
+        scalarField etaCut_;
+
+        //- Sizes of piecewise uniform intervals
+        labelList nSpacings_;
+
+        //- Mixture fraction eta grid points
+        scalarField etaSpace_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        BetaGrid(const BetaGrid&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const BetaGrid&);
+
+
+public:
+
+    // Static data members
+
+        //- Static data staticData
+        // static const scalar staticData;
+
+
+    // Constructors
+
+        //- Construct from components
+        BetaGrid(const dictionary& dict);
+
+        //- Construct from Istream
+        BetaGrid(Istream&);
+
+        //- Construct as copy
+        // BetaGrid(const BetaGrid&);
+
+
+    //- Destructor
+    ~BetaGrid();
+
+
+    // Member Functions
+
+        // Access
+        const labelList& N() const {return nSpacings_;}
+
+        const scalarField& etaCut() const {return etaCut_;}
+
+        const scalarField& etaSpace() const {return etaSpace_;}
+
+        // Check
+
+        // Edit
+
+        // Write
+
+
+    // Member Operators
+
+        // void operator=(const BetaGrid&);
+
+
+    // Friend Functions
+
+    // Friend Operators
+
+    // IOstream Operators
+
+        friend Istream& ::Foam::operator>>(Istream&, BetaGrid&);
+        friend Ostream& ::Foam::operator<<(Ostream&, const BetaGrid&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace CMC
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "BetaGridI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaGrid/BetaGridI.H

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaGrid/BetaGridIO.C

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaGrid.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaGrid::BetaGrid(Istream& is)
+{
+    // Check state of Istream
+    is.check("Foam::CMC::BetaGrid::BetaGrid(Foam::Istream&)");
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaGrid&)
+{
+    // Check state of Istream
+    is.check
+    (
+        "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaGrid&)"
+    );
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaGrid&)
+{
+    // Check state of Ostream
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
+        "const Foam::CMC::BetaGrid&)"
+    );
+
+    return os;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaIntegrator/BetaIntegrator.C

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaIntegrator.H"
+
+
+#include "error.H"
+#include "SubList.H"
+#include "SubField.H"
+#include "interpolateXY.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// const scalar Foam::CMC::BetaIntegrator::staticData();
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+//extended Simpson's rule (Numerical recipes, 2nd Ed. p.128)
+//for equally spaced and even N intervals (or odd N+1 points)
+Foam::scalar Foam::CMC::BetaIntegrator::simps
+(const scalar xl, const scalar xh, const label n, const UList<scalar>& fx)
+    const
+{
+    scalar evensum(0.0), oddsum(0.0), sum(0.0);
+
+    scalar h = (xh - xl)/scalar(n);
+
+    for(label i=0 ; i<fx.size() ; i++)
+    {
+        if(i%2 == 0)
+        {
+            evensum += fx[i];
+        }
+        else
+        {
+            oddsum += fx[i];
+        }
+    }
+
+    sum = -1.0*fx.first() + 2.0*evensum + 4.0*oddsum - 1.0*fx.last();
+
+    return sum*(h/3.0);
+}
+
+
+Foam::scalar Foam::CMC::BetaIntegrator::sumSimps(const UList<scalar>& f) const
+{
+    scalar total = 0.0;
+
+    const labelList &N(bg_.N());
+    const scalarField &etaCut(bg_.etaCut());
+
+    forAll(N, i)
+    {
+        const labelList::subList prev(N, i);
+        const label baseI = sum(prev) + 1;
+
+        const scalarField::subField subInterval(f, N[i]+1, baseI);
+
+        total += simps(etaCut[i], etaCut[i+1], N[i], subInterval);
+    }
+
+    return total;
+}
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaIntegrator::BetaIntegrator(const BetaFunction& bf, const BetaGrid &bg)
+:
+    etaSpace_(bg.etaSpace()),
+    pdfNum_(bg.etaSpace().size(), 0.0),
+    pdfDen_(0.0),
+    bf_(bf),
+    bg_(bg)
+{
+    const scalarField::subField domain(etaSpace_, etaSpace_.size()-2, 1);
+    scalarField::subField range(pdfNum_, etaSpace_.size()-2, 1);
+
+    if (bf_.fdelta())
+    {
+        pdfDen_ = 1.0;
+    }
+    else
+    {
+        range = bf_.etaFunc(domain);
+
+        if (!bf_.delta0())
+        {
+            pdfNum_.first() = bf_.etaFunc(etaSpace_.first());
+        }
+
+        if (!bf_.delta1())
+        {
+            pdfNum_.last() = bf_.etaFunc(etaSpace_.last());
+        }
+
+        pdfDen_ = sumSimps(pdfNum_)
+            + Foam::pow(etaSpace_[1], bf_.alpha())/(bf_.alpha() + SMALL)
+            + Foam::pow(etaSpace_[1], bf_.beta())/(bf_.beta() + SMALL);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::CMC::BetaIntegrator::~BetaIntegrator()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+// beta-pdf weighted integration for given mf, mfVar and f
+Foam::scalar Foam::CMC::BetaIntegrator::betaIntegrate(const scalarField& f) const
+{
+    scalar result = 0.0;
+
+    if(bf_.fdelta())
+    {
+        result = interpolateXY(bf_.mf(), etaSpace_, f);
+    }
+    else
+    {
+        scalar num = sumSimps (f * pdfNum_)
+            + f.first()*Foam::pow(etaSpace_[1], bf_.alpha())/(bf_.alpha() + SMALL)
+            + f.last()*Foam::pow(etaSpace_[1], bf_.beta())/(bf_.beta() + SMALL);
+        result = num/pdfDen_;
+    }
+
+    return result;
+}
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+void Foam::CMC::BetaIntegrator::operator=(const BetaIntegrator& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorInFunction
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaIntegrator/BetaIntegrator.H

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::CMC::BetaIntegrator
+
+Description
+
+SourceFiles
+    BetaIntegratorI.H
+    BetaIntegrator.C
+    BetaIntegratorIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef BetaIntegrator_H
+#define BetaIntegrator_H
+
+#include "scalarField.H"
+#include "BetaFunction.H"
+#include "BetaGrid.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+namespace CMC
+{
+    class BetaIntegrator;
+}
+Istream& operator>>(Istream&, CMC::BetaIntegrator&);
+Ostream& operator<<(Ostream&, const CMC::BetaIntegrator&);
+
+
+/*---------------------------------------------------------------------------*\
+                         Class BetaIntegrator Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace CMC
+{
+
+class BetaIntegrator
+{
+    // Private data
+
+        //- Quadrature points
+        const scalarField &etaSpace_;
+
+        //- Beta pdf numerators
+        scalarField pdfNum_;
+
+        //- Beta pdf denominator
+        scalar pdfDen_;
+
+        //- Description of data_
+        BetaFunction bf_;
+
+        //- Description of data_
+        const BetaGrid &bg_;
+
+
+    // Private Member Functions
+
+        //- Calculate integral using Simpson's rule
+        scalar simps(const scalar xl, const scalar xh, const label n, const UList<scalar>& fx) const;
+
+        //- Calculate integral using Simpson's rule
+        scalar sumSimps(const UList<scalar>& f) const;
+
+        //- Disallow default bitwise copy construct
+        BetaIntegrator(const BetaIntegrator&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const BetaIntegrator&);
+
+
+public:
+
+    // Static data members
+
+        //- Static data staticData
+        // static const scalar staticData;
+
+
+    // Constructors
+
+        //- Construct from components
+        BetaIntegrator(const BetaFunction& bf, const BetaGrid &bg);
+
+        //- Construct as copy
+        // BetaIntegrator(const BetaIntegrator&);
+
+
+    //- Destructor
+    ~BetaIntegrator();
+
+
+    // Member Functions
+
+        scalar betaIntegrate(const scalarField& f) const;
+
+        // Access
+
+        scalar pdfDen () const {return pdfDen_;}
+
+        // Check
+
+        // Edit
+
+        // Write
+
+
+    // Member Operators
+
+        // void operator=(const BetaIntegrator&);
+
+
+    // Friend Functions
+
+    // Friend Operators
+
+    // IOstream Operators
+
+        friend Istream& ::Foam::operator>>(Istream&, BetaIntegrator&);
+        friend Ostream& ::Foam::operator<<(Ostream&, const BetaIntegrator&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace CMC
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "BetaIntegratorI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaIntegrator/BetaIntegratorI.H

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/BetaIntegrator/BetaIntegratorIO.C

@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "BetaIntegrator.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaIntegrator&)
+{
+    // Check state of Istream
+    is.check
+    (
+        "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaIntegrator&)"
+    );
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaIntegrator&)
+{
+    // Check state of Ostream
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
+        "const Foam::CMC::BetaIntegrator&)"
+    );
+
+    return os;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/FlameStructure/FlameStructure.C

@@ -0,0 +1,206 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "FlameStructure.H"
+
+#include "fileName.H"
+#include "IFstream.H"
+#include "hashedWordList.H"
+#include "interpolateXY.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::SLFM::FlameStructure::FlameStructure(const string& NstDir, scalarList NstList, const scalarField &etaGrid, const hashedWordList &spTable)
+:
+    NstDir_(NstDir),
+    NstList_(NstList),
+    eta_(etaGrid),
+    species_(spTable),
+    Y_(spTable.size(), scalarFieldArray1d(NstList_.size(), scalarField(eta_.size(), 0.0))),
+    W_(spTable.size(), scalarFieldArray1d(NstList_.size(), scalarField(eta_.size(), 0.0))),
+    T_(NstList_.size(), scalarField(eta_.size(), 0.0)),
+    Q_(NstList_.size(), scalarField(eta_.size(), 0.0)),
+    h_(NstList_.size(), scalarField(eta_.size(), 0.0)),
+    rho_(NstList_.size(), scalarField(eta_.size(), 0.0)),
+    Rgas_(NstList_.size(), scalarField(eta_.size(), 0.0))
+{
+    for (label n = 0; n < NstList_.size(); n++)
+    {
+        scalar N = NstList_[n];
+
+        fileName fname = "sdr"+Foam::name(N)+".inp";
+        IFstream fin(NstDir_/fname);
+
+        string gbg;
+        label etamax_SLFM, NoSpecies;
+
+        //INPUT FILE...
+        fin.getLine(gbg);
+
+        //No.GRID...
+        fin.getLine(gbg);
+
+        //Number of eta-point and species
+        fin >> etamax_SLFM >> NoSpecies;
+
+        //blank line
+        fin.getLine(gbg);
+
+        //PRESSURE...
+        fin.getLine(gbg);
+
+        //1.00...
+        fin.getLine(gbg);
+
+        //MIXTURE...
+        fin.getLine(gbg);
+
+        //read eta space (from SLFM library)
+        scalarField etaValue_SLFM(etamax_SLFM, 0.0);
+        for(label j = 0 ; j < etamax_SLFM ; j++)
+        {
+            fin>>etaValue_SLFM[j];
+        }
+
+        //blank line
+        fin.getLine(gbg);
+
+        //INITIAL...
+        fin.getLine(gbg);
+
+        //species loop
+        scalarField temp(etamax_SLFM, 0.0);
+        for(label i = 0 ; i < NoSpecies ; i++)
+        {
+            word spName;
+            //H2... (species name)
+            fin >> spName;
+            const label spI (species_[spName]);
+
+            // Info << spI << spName << endl;
+
+            //read species mass fraction (from SLFM library)
+            for(label j=0 ; j<etamax_SLFM ; j++)
+            {
+                scalar Yj = 0.0;
+                fin >> Yj;
+                temp[j] = max(0.0, Yj);
+            }
+
+            Y_[spI][n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+
+            //read reaction rate (from SLFM library)
+            for(label j = 0 ; j < etamax_SLFM ; j++)
+            {
+                fin>>temp[j];
+            }
+
+            W_[spI][n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+
+            //blank line
+            fin.getLine(gbg);
+        }
+
+        //read temperature
+        {
+            //H2... (species name)
+            fin.getLine(gbg);
+
+            //read temperature
+            for(label j = 0 ; j < etamax_SLFM ; j++)
+            {
+                scalar Yj = 0.0;
+                fin >> Yj;
+                temp[j] = max(0.0, Yj);
+            }
+
+            T_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+
+            //read heat source
+            for(label j = 0 ; j < etamax_SLFM ; j++)
+            {
+                fin>>temp[j];
+            }
+
+            Q_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+
+            //blank line
+            fin.getLine(gbg);
+        }
+
+        //DENSITY...
+        fin.getLine(gbg);
+
+        //read density (from SLFM library)
+        for(label j = 0 ; j < etamax_SLFM ; j++)
+        {
+            fin>>temp[j];
+        }
+        //Info<<rho_temp<<endl;
+
+        rho_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+
+        //blank line
+        fin.getLine(gbg);
+
+        //ENTHALPY...
+        fin.getLine(gbg);
+
+        //read enthalpy (from SLFM library)
+        for(label j = 0 ; j < etamax_SLFM ; j++)
+        {
+            fin>>temp[j];
+        }
+
+        h_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::SLFM::FlameStructure::~FlameStructure()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/FlameStructure/FlameStructure.H

@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::SLFM::FlameStructure
+
+Description
+
+SourceFiles
+    FlameStructureI.H
+    FlameStructure.C
+    FlameStructureIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef FlameStructure_H
+#define FlameStructure_H
+
+#include "error.H"
+#include "scalarField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+class hashedWordList;
+
+namespace SLFM
+{
+    class FlameStructure;
+}
+
+// Forward declaration of friend functions and operators
+Istream& operator>>(Istream&, SLFM::FlameStructure&);
+Ostream& operator<<(Ostream&, const SLFM::FlameStructure&);
+
+namespace SLFM
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class FlameStructure Declaration
+\*---------------------------------------------------------------------------*/
+
+class FlameStructure
+{
+    // Private data
+        typedef List<scalarField> scalarFieldArray1d;
+
+        typedef List<scalarFieldArray1d> scalarFieldArray2d;
+
+        typedef List<scalarFieldArray2d> scalarFieldArray3d;
+
+        //- Species mass fraction
+        word NstDir_;
+
+        //- Species mass fraction
+        const scalarList NstList_;
+
+        //- Species mass fraction
+        const scalarField eta_;
+
+        //- Species mass fraction
+        const hashedWordList &species_;
+
+        //- Species mass fraction
+        scalarFieldArray2d Y_;
+
+        //- Species production rate
+        scalarFieldArray2d W_;
+
+        //- Temperature
+        scalarFieldArray1d T_;
+
+        //- Heat source
+        scalarFieldArray1d Q_;
+
+        //- Enthalpy
+        scalarFieldArray1d h_;
+
+        //- Density
+        scalarFieldArray1d rho_;
+
+        //- Specific gas constant for mean W
+        scalarFieldArray1d Rgas_;
+
+
+    // Private Member Functions
+
+        //- Disallow Construct null
+        FlameStructure();
+
+        //- Disallow default bitwise copy construct
+        // FlameStructure(const FlameStructure&);
+
+        //- Disallow default bitwise assignment
+        // void operator=(const FlameStructure&);
+
+
+public:
+
+    // Static data members
+
+        //- Static data staticData
+        // static const dataType staticData;
+
+
+    // Constructors
+
+        //- Construct from components
+        FlameStructure(const string& NstDir, scalarList NstList, const scalarField &etaGrid, const hashedWordList& spTable);
+
+        //- Construct from Istream
+        // FlameStructure(Istream&);
+
+        //- Construct as copy
+        // FlameStructure(const FlameStructure&);
+
+
+    // Selectors
+
+        //- Select null constructed
+        // static autoPtr<FlameStructure> New();
+
+
+    //- Destructor
+    ~FlameStructure();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Select null constructed
+            scalarFieldArray2d& Y() {return Y_;}
+
+            //- Select null constructed
+            scalarFieldArray2d& W() {return W_;}
+
+            //- Select null constructed
+            scalarFieldArray1d& T() {return T_;}
+
+            //- Select null constructed
+            scalarFieldArray1d& Q() {return Q_;}
+
+            //- Select null constructed
+            scalarFieldArray1d& rho() {return rho_;}
+
+            //- Select null constructed
+            scalarFieldArray1d& h() {return h_;}
+
+            //- Select null constructed
+            scalarFieldArray1d& Rgas() {return Rgas_;}
+
+        // Check
+
+        // Edit
+
+        // Write
+
+
+    // Member Operators
+
+        // void operator=(const FlameStructure&);
+
+
+    // Friend Functions
+
+    // Friend Operators
+
+    // IOstream Operators
+
+        friend Istream& operator>>(Istream&, FlameStructure&);
+        friend Ostream& operator<<(Ostream&, const FlameStructure&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace SLFM
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "FlameStructureI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/FlameStructure/FlameStructureI.H

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/FlameStructure/FlameStructureIO.C

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "FlameStructure.H"
+#include "IOstreams.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+    /*
+Foam::SLFM::FlameStructure::FlameStructure(Istream& is)
+:
+    base1(is),
+    base2(is),
+    member1(is),
+    member2(is)
+{
+    // Check state of Istream
+    is.check("Foam::SLFM::FlameStructure::FlameStructure(Foam::Istream&)");
+}
+    */
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, SLFM::FlameStructure&)
+{
+    // Check state of Istream
+    is.check
+    (
+        "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::SLFM::FlameStructure&)"
+    );
+
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const SLFM::FlameStructure&)
+{
+    // Check state of Ostream
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
+        "const Foam::SLFM::FlameStructure&)"
+    );
+
+    return os;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/Make/files

@@ -0,0 +1,17 @@
+FlameStructure/FlameStructure.C
+FlameStructure/FlameStructureIO.C
+
+./AMC/AMC.C
+
+./BetaFunction/BetaFunction.C
+./BetaFunction/BetaFunctionIO.C
+
+./BetaGrid/BetaGrid.C
+./BetaGrid/BetaGridIO.C
+
+./BetaIntegrator/BetaIntegrator.C
+./BetaIntegrator/BetaIntegratorIO.C
+
+SLFMFoam.C
+
+EXE = $(FOAM_APPBIN)/SLFMFoam

applications/solvers/combustion/SLFMFoam/Make/options

@@ -0,0 +1,34 @@
+EXE_INC = \
+    -I. \
+    -I./AMC \
+    -I./BetaFunction \
+    -I./BetaGrid \
+    -I./BetaIntegrator \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
+    -I$(LIB_SRC)/ODE/lnInclude \
+    -I$(LIB_SRC)/combustionModels/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lspecie \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lreactionThermophysicalModels \
+    -lchemistryModel \
+    -lODE \
+    -lcombustionModels \
+    -lfvOptions \
+    -lsampling

applications/solvers/combustion/SLFMFoam/Mixturefraction.H

@@ -0,0 +1,10 @@
+// mixture fraction equation
+fvScalarMatrix mfEqn
+(
+    fvm::div(phi, mf)
+  - fvm::laplacian((1/Sc)*turbulence->mut(), mf) //let 1/Sc = 1.47
+);
+
+mfEqn.relax();
+
+mfEqn.solve();

applications/solvers/combustion/SLFMFoam/MixturefractionVar.H

@@ -0,0 +1,17 @@
+//mixture fraction variance equation
+//cf) mfVar should not be ZERO
+SDR = turbulence->epsilon() * mfVar / turbulence->k();
+volVectorField Gradmf = fvc::grad(mf);
+
+fvScalarMatrix mfVarEqn
+(
+    fvm::div(phi, mfVar)
+  - fvm::laplacian((1/Sc) * turbulence->mut(), mfVar)
+ ==
+    2 * ((1/Sc) * turbulence->mut()) * (Gradmf & Gradmf)
+  - 2 * rho * SDR
+);
+
+mfVarEqn.relax();
+
+mfVarEqn.solve();

applications/solvers/combustion/SLFMFoam/SLFMFoam.C

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    SLFMFoam
+
+Description
+    Steady Laminar Flamelet Model(SLFM) solver for turbulent combustion. SLFM
+    assumes a turbulent flame composed of thin stretched laminar flamelets.
+    Each flamelet library is generated by external program and imported by
+    the solver.
+
+References
+    A.Y. Klimenko, R.W. Bilger, Progress in Energy and Combustion Science 25 (1999) 595-687
+    N. Peters, Turbulent Combustion, Cambridge University Press (2000)
+
+Contact
+    POSTECH combustion lab.
+    huh@postech.ac.kr
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "turbulentFluidThermoModel.H"
+#include "rhoCombustionModel.H"
+#include "fvOptions.H"
+#include "simpleControl.H"
+#include "FlameStructure/FlameStructure.H"
+#include "interpolateXY.H"
+
+#include "AMC.H"
+#include "BetaFunction.H"
+#include "BetaGrid.H"
+#include "BetaIntegrator.H"
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "postProcess.H"
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createControl.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "createFvOptions.H"
+    #include "initContinuityErrs.H"
+
+    turbulence->validate();
+
+    //SLFM
+    Info<<"Read SLFM library"<<endl;
+    #include "readSLFMlib.H" //read SLFM library
+
+    Info<<"Construct Beta-PDF"<<endl;
+    #include "preIntegration.H" //AMC C1 coefficient pdf integration
+
+    Info<< "\nStarting time loop\n" << endl;
+
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (simple.loop())
+    {
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        // --- Pressure-velocity SIMPLE corrector loop
+        {
+            #include "UEqn.H"
+            #include "Mixturefraction.H" //mean mixture fraction
+            #include "MixturefractionVar.H" //mean mixture fraction variance
+            #include "setSDR.H" //calculate scalar dissipation rate
+            #include "updateT_RHO.H" //update temperature and density
+            #include "pEqn.H"
+        }
+
+        turbulence->correct();
+
+        if (runTime.write())
+        {
+            #include "updateYi.H" //update species
+        }
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/SLFMFoam/UEqn.H

@@ -0,0 +1,20 @@
+    MRF.correctBoundaryVelocity(U);
+
+    tmp<fvVectorMatrix> tUEqn
+    (
+        fvm::div(phi, U)
+      + MRF.DDt(rho, U)
+      + turbulence->divDevRhoReff(U)
+     ==
+        rho()*g
+      + fvOptions(rho, U)
+    );
+    fvVectorMatrix& UEqn = tUEqn.ref();
+
+    UEqn.relax();
+
+    fvOptions.constrain(UEqn);
+
+    solve(UEqn == -fvc::grad(p));
+
+    fvOptions.correct(U);

applications/solvers/combustion/SLFMFoam/createFieldRefs.H

@@ -0,0 +1,2 @@
+const volScalarField& psi = thermo.psi();
+//const volScalarField& T = thermo.T();

applications/solvers/combustion/SLFMFoam/createFields.H

@@ -0,0 +1,374 @@
+#include "readGravitationalAcceleration.H"
+
+Info<< "Creating combustion model\n" << endl;
+
+autoPtr<combustionModels::rhoCombustionModel> combustion
+(
+    combustionModels::rhoCombustionModel::New(mesh)
+);
+
+rhoReactionThermo& thermo = combustion->thermo();
+thermo.validate(args.executable(), "h", "e");
+
+basicSpecieMixture& composition = thermo.composition();
+PtrList<volScalarField>& Y = composition.Y();
+
+const word inertSpecie(thermo.lookup("inertSpecie"));
+
+if (!composition.contains(inertSpecie))
+{
+    FatalErrorInFunction
+        << "Specified inert specie '" << inertSpecie << "' not found in "
+        << "species list. Available species:" << composition.species()
+        << exit(FatalError);
+}
+
+volScalarField& p = thermo.p();
+volScalarField& T = thermo.T();
+
+wordList rhoBoundaryTypes
+(
+	T.boundaryField().size(),
+	zeroGradientFvPatchScalarField::typeName
+);
+
+forAll(composition.Y(inertSpecie).boundaryField(), patchi)
+{
+	rhoBoundaryTypes[patchi]
+        = composition.Y(inertSpecie).boundaryField()[patchi].type();
+}
+
+
+volScalarField rho
+(
+    IOobject
+    (
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho(),
+    rhoBoundaryTypes
+);
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+mesh.setFluxRequired(p.name());
+
+dimensionedScalar rhoMax
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMax",
+        simple.dict(),
+        dimDensity,
+        GREAT
+    )
+);
+
+dimensionedScalar rhoMin
+(
+    dimensionedScalar::lookupOrDefault
+    (
+        "rhoMin",
+        simple.dict(),
+        dimDensity,
+        0
+    )
+);
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+// Set the turbulence into the combustion model
+combustion->setTurbulence(turbulence());
+
+Info<< "Creating multi-variate interpolation scheme\n" << endl;
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+forAll(Y, i)
+{
+    fields.add(Y[i]);
+}
+fields.add(thermo.he());
+
+
+// SLFM-related fields
+
+Info<<"Creating field mf, mfVar, SDR\n"<<endl;
+
+volScalarField mf //mixture fraction
+(
+    IOobject
+    (
+        "mf",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+volScalarField mfVar //mixture fraction variance
+(
+    IOobject
+    (
+        "mfVar",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+volScalarField SDR //scalar dissipation rate
+(
+    IOobject
+    (
+        "SDR",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("SDR", dimEnergy/dimTime/dimEnergy, 0.0)
+);
+
+volScalarField jlc //eta-index, lower
+(
+    IOobject
+    (
+        "jlc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("jlc", dimless, 0.0)
+);
+
+volScalarField jhc //eta-index, higher
+(
+    IOobject
+    (
+        "jhc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("jhc", dimless, 0.0)
+);
+
+volScalarField jfc //eta-factor
+(
+    IOobject
+    (
+        "jfc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("jfc", dimless, 0.0)
+);
+
+volScalarField vlc //var-index, lower
+(
+    IOobject
+    (
+        "vlc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("vlc", dimless, 0.0)
+);
+
+volScalarField vhc //var-index, higher
+(
+    IOobject
+    (
+        "vhc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("vhc", dimless, 0.0)
+);
+
+volScalarField vfc //var-factor
+(
+    IOobject
+    (
+        "vfc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("vfc", dimless, 0.0)
+);
+
+volScalarField nlc //sdr-index, lower
+(
+    IOobject
+    (
+        "nlc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("nlc", dimless, 0.0)
+);
+
+volScalarField nhc //sdr-index, higher
+(
+    IOobject
+    (
+        "nhc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("nhc", dimless, 0.0)
+);
+
+volScalarField nfc //sdr-factor
+(
+    IOobject
+    (
+        "nfc",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("nfc", dimless, 0.0)
+);
+
+//SLFM property read
+
+IOdictionary SLFMdict //SLFM properties dictionary
+(
+    IOobject
+    (
+        "SLFMdict",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    )
+);
+
+const wordList postSpecieNames(SLFMdict.lookup("postSpecieNames"));
+labelList postSpecieIndices(postSpecieNames.size(),-1);
+forAll(postSpecieNames, i)
+{
+    const word &spName (postSpecieNames[i]);
+    const label spI (composition.species()[spName]);
+    postSpecieIndices[i] = spI;
+}
+scalar stoiMF(readScalar(SLFMdict.lookup("stoiMF")));
+scalar stretchFac(readScalar(SLFMdict.lookup("stretchFactor")));
+scalar lowerN(readScalar(SLFMdict.lookup("lowerN")));
+scalar upperN(readScalar(SLFMdict.lookup("upperN")));
+scalar Sc(readScalar(SLFMdict.lookup("Sc")));
+const label etamax(lowerN+upperN+1);
+word outletName(SLFMdict.lookup("outletName"));
+
+labelList nIntervals (SLFMdict.lookup("detailedN"));
+
+CMC::BetaGrid bg(SLFMdict);
+const scalarField &etaGrid(bg.etaSpace());
+const scalarField amcGridValue(CMC::AMC(etaGrid));
+
+Info << etaGrid << endl;
+
+scalarField etaValue(etamax,0);
+scalarField etaIndex(etamax,0);
+scalarField deta_h(etamax,0);
+scalarField deta_l(etamax,0);
+scalarField deta_m(etamax,0);
+
+#include "setEtaSpace.H"
+
+Info<<"\nNumber of eta-point = "<<etamax<<endl;
+
+
+scalar NVar(readScalar(SLFMdict.lookup("NVar")));
+scalarField varValue(NVar+1,0);
+scalarField varIndex(NVar+1,0);
+
+#include "setVarSpace.H"
+
+
+
+PtrList<volScalarField> Neta(etamax);
+
+for(label j=0 ; j<etamax ; j++)
+{
+
+
+    word Netai = "Neta_"+Foam::name(j);
+    Neta.set
+    (
+        j,
+        new volScalarField
+        (
+            IOobject
+            (
+                Netai,
+                runTime.timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh,
+            dimensionedScalar(Netai, dimless, 0.0)
+        )
+    );
+}
+
+#include "createMRF.H"

applications/solvers/combustion/SLFMFoam/pEqn.H

@@ -0,0 +1,55 @@
+{
+    // Thermodynamic density needs to be updated by psi*d(p) after the
+    // pressure solution - done in 2 parts. Part 1:
+    thermo.rho() -= psi*p;
+
+    volScalarField rAU(1.0/UEqn.A());
+    surfaceScalarField rhorAUf("rhorAUf", fvc::interpolate(rho*rAU));
+    volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p));
+    tUEqn.clear();
+    surfaceScalarField phiHbyA
+    (
+        "phiHbyA",
+        fvc::interpolate(rho)*fvc::flux(HbyA)
+    );
+
+    MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
+
+    // Update the pressure BCs to ensure flux consistency
+    constrainPressure(p, rho, U, phiHbyA, rhorAUf, MRF);
+
+    while (simple.correctNonOrthogonal())
+    {
+        fvScalarMatrix pEqn
+        (
+            fvc::div(phiHbyA)
+          - fvm::laplacian(rhorAUf, p)
+         ==
+            fvOptions(psi, p, rho.name())
+        );
+
+        pEqn.solve();
+
+        if (simple.finalNonOrthogonalIter())
+        {
+            phi = phiHbyA + pEqn.flux();
+        }
+    }
+
+    p.relax();
+
+    // Second part of thermodynamic density update
+    thermo.rho() += psi*p;
+
+    #include "compressibleContinuityErrs.H"
+
+    U = HbyA - rAU*fvc::grad(p);
+    U.correctBoundaryConditions();
+    fvOptions.correct(U);
+
+    rho = max(rho, rhoMin);
+    rho = min(rho, rhoMax);
+    rho.relax();
+
+    Info<< "p min/max = " << min(p).value() << ", " << max(p).value() << endl;
+}

applications/solvers/combustion/SLFMFoam/preIntegration.H

@@ -0,0 +1,78 @@
+scalarFieldArray1d C1table //AMC C1 coefficient table
+(
+    etamax,
+    scalarField(NVar+1, 0)
+);
+
+scalarFieldArray2d Ttable
+(
+    etamax,
+    scalarFieldArray1d
+    (
+        NVar+1,
+        scalarField(NstList.size(), 0)
+    )
+);
+
+scalarFieldArray2d Rtable
+(
+    etamax,
+    scalarFieldArray1d
+    (
+        NVar+1,
+        scalarField(NstList.size(), 0)
+    )
+);
+
+scalarFieldArray3d Ytable
+(
+    Y.size(),
+    scalarFieldArray2d
+    (
+        etamax,
+        scalarFieldArray1d
+        (
+            NVar+1,
+            scalarField(NstList.size(), 0)
+        )
+    )
+);
+
+Info<<"Construct C1 coefficient table"<<endl;
+for(label j = 1; j < etamax - 1; j++)
+{
+    for(label v = 1; v < varValue.size() - 1; v++)
+    {
+        const scalar mf = etaValue[j];
+        const scalar mfVar = varValue[v]*mf*(1.0-mf);
+
+        CMC::BetaFunction bf(mf, mfVar);
+        CMC::BetaIntegrator bi(bf, bg);
+
+        C1table[j][v] = 1.0/bi.betaIntegrate(amcGridValue);
+    }
+}
+
+Info<<"Construct Temp and Rgas table"<<endl;
+for(label j=0 ; j<etamax ; j++)
+{
+    for(label v=0 ; v<=NVar ; v++)
+    {
+        const scalar mf = etaValue[j];
+        const scalar mfVar = varValue[v]*mf*(1.0-mf);
+
+        CMC::BetaFunction bf(mf, mfVar);
+        CMC::BetaIntegrator bi(bf, bg);
+
+        for(label n=0 ; n<NstList.size() ; n++)
+        {
+            Ttable[j][v][n] = bi.betaIntegrate(T_SLFM[n]);
+            Rtable[j][v][n] = bi.betaIntegrate(Rgas_SLFM[n]);
+            forAll(Y, yi)
+            {
+                Ytable[yi][j][v][n] = bi.betaIntegrate(Y_SLFM[yi][n]);
+            }
+        }
+    }
+    Info<<scalar(j+1)/etamax*100<<"%"<<endl;
+}

applications/solvers/combustion/SLFMFoam/readSLFMlib.H

@@ -0,0 +1,33 @@
+Switch Equilibrium = SLFMdict.lookup("Equilibrium");
+word NstFolder = SLFMdict.lookup("NstFolder");
+scalarField NstList = SLFMdict.lookup("NstList");
+scalarField NstIndex(NstList.size(),0);
+
+forAll(NstList, n)
+{
+    NstIndex[n] = n;
+}
+
+typedef List<scalarField> scalarFieldArray1d;
+typedef List<scalarFieldArray1d> scalarFieldArray2d;
+typedef List<scalarFieldArray2d> scalarFieldArray3d;
+
+SLFM::FlameStructure slfmLibrary(runTime.constant()/NstFolder, NstList, etaGrid, composition.species());
+
+scalarFieldArray2d& Y_SLFM (slfmLibrary.Y());
+scalarFieldArray2d& W_SLFM (slfmLibrary.W());
+scalarFieldArray1d& T_SLFM (slfmLibrary.T());
+scalarFieldArray1d& Q_SLFM (slfmLibrary.Q());
+scalarFieldArray1d& rho_SLFM (slfmLibrary.rho());
+scalarFieldArray1d& h_SLFM (slfmLibrary.h());
+scalarFieldArray1d& Rgas_SLFM (slfmLibrary.Rgas());
+
+for(label n=0 ; n<NstList.size() ; n++)
+{
+    for(label i=0 ; i<Y.size() ; i++)
+    {
+        Rgas_SLFM[n] += Y_SLFM[i][n]/composition.W(i); // = 1/meanMW
+    }
+    Rgas_SLFM[n] = 8314.46*Rgas_SLFM[n]; //universal gas constant = 8314.46 [J/K.Kmole]
+
+}

applications/solvers/combustion/SLFMFoam/setEtaSpace.H

@@ -0,0 +1,51 @@
+//set eta-space
+scalar upperSum(0), upperDelta(0);
+scalar lowerSum(0), lowerDelta(0);
+
+//summation of geometric progression (eta > stoi)
+upperSum = Foam::pow(stretchFac,upperN)-1.0;
+upperSum = upperSum/(stretchFac-1.0);
+
+//summation of geometric progression (eta < stoi)
+lowerSum = Foam::pow(stretchFac,lowerN)-1.0;
+lowerSum = lowerSum/(stretchFac-1.0);
+
+//set reference delta eta
+upperDelta = (1.0-stoiMF)/upperSum;
+lowerDelta = stoiMF/lowerSum;
+
+//set boundary and stoichiometric value of eta
+etaValue[0] = 0.0;
+etaValue[lowerN] = stoiMF;
+etaValue.last() = 1.0;
+
+//set internal value of eta (eta > stoi)
+for(label j=0 ; j<upperN-1 ; j++)
+{
+    etaValue[lowerN+j+1] = etaValue[lowerN+j] + upperDelta*pow(stretchFac,j);
+}
+
+//set internal value of eta (eta < stoi)
+for(label j=0 ; j<lowerN-1 ; j++)
+{
+    etaValue[lowerN-j-1] = etaValue[lowerN-j] - lowerDelta*pow(stretchFac,j);
+}
+
+Info<<etaValue<<endl;
+
+//calculate delta eta
+for(label j=1 ; j<etamax-1 ; j++)
+{
+    deta_h[j] = etaValue[j+1] - etaValue[j];
+    deta_l[j] = etaValue[j] - etaValue[j-1];
+    deta_m[j] = 0.5*(etaValue[j+1] - etaValue[j-1]);
+}
+
+//Info<<deta_h<<endl;
+//Info<<deta_l<<endl;
+//Info<<deta_m<<endl;
+
+for(label j=0 ; j<etamax ; j++)
+{
+    etaIndex[j] = j;
+}

applications/solvers/combustion/SLFMFoam/setSDR.H

@@ -0,0 +1,79 @@
+scalarField AMCcoeff(CMC::AMC(etaValue));
+
+//cell loop
+
+forAll(mf, cellI)
+{
+
+
+    scalar jl(0), jh(0), vl(0), vh(0);
+    scalar jfac(0), vfac(0);
+    scalar C1coeff(0);
+
+    //find eta-index, factor
+    if(mf[cellI] < etaValue[1])
+    {
+        jl = 0;
+        jh = 1;
+    }
+    else if(mf[cellI] > etaValue[etamax-2])
+    {
+        jl = etamax-2;
+        jh = etamax-1;
+    }
+    else
+    {
+        jl = label( interpolateXY(mf[cellI], etaValue, etaIndex) );
+        jh = jl+1;
+    }
+    jfac = max(0.0, (mf[cellI]-etaValue[jl])/(etaValue[jh]-etaValue[jl]));
+
+    //find var-index, factor
+    scalar scaledVar = min(0.99999, mfVar[cellI]/(mf[cellI]*(1.0-mf[cellI])+SMALL));
+    if(scaledVar < varValue[1])
+    {
+        vl = 0;
+        vh = 1;
+    }
+    else if(scaledVar > varValue[NVar-1])
+    {
+        vl = NVar-1;
+        vh = NVar;
+    }
+    else
+    {
+        vl = label( interpolateXY(scaledVar, varValue, varIndex) );
+        vh = vl+1;
+    }
+    vfac = max(0.0, (scaledVar-varValue[vl])/(varValue[vh]-varValue[vl]));
+
+
+    //Bi-linear interpolation on j and v
+    //Numerical recipes, 2nd Ed. p.117
+    C1coeff
+    = C1table[jl][vl]*(1-jfac)*(1-vfac)
+    + C1table[jh][vl]*(jfac)*(1-vfac)
+    + C1table[jh][vh]*(jfac)*(vfac)
+    + C1table[jl][vh]*(1-jfac)*(vfac);
+
+    jlc[cellI] = jl;
+    jhc[cellI] = jh;
+    jfc[cellI] = jfac;
+    vlc[cellI] = vl;
+    vhc[cellI] = vh;
+    vfc[cellI] = vfac;
+
+
+    scalar Coeff = AMCcoeff[lowerN];
+
+    if (Equilibrium == true)
+    {
+        Neta[lowerN][cellI] = 0; //Equilibrium
+    }
+    else
+    {
+        Neta[lowerN][cellI] = SDR[cellI]*Coeff*C1coeff; //CSDR at stoichiometic m.f.
+    }
+}
+
+

applications/solvers/combustion/SLFMFoam/setVarSpace.H

@@ -0,0 +1,23 @@
+//set normalized variance space
+{
+    scalar sum(0), del(0), fac(1.075);
+
+    sum = Foam::pow(fac,NVar) - 1.0;
+    sum = sum/(fac-1.0);
+
+    del = 1.0/sum;
+
+    varValue[0] = 0.0;
+    varValue[NVar] = 1.0;
+
+    for(label v=0 ; v<NVar-1 ; v++)
+    {
+        varValue[v+1] = varValue[v] + del*Foam::pow(fac,v);
+    }
+
+    for(label v=0 ; v<=NVar ; v++)
+    {
+        varIndex[v] = v;
+    }
+    Info<<varValue<<endl;
+}

applications/solvers/combustion/SLFMFoam/updateT_RHO.H

@@ -0,0 +1,60 @@
+//force the saving of the old-time values
+//important!!
+
+rho.oldTime();
+
+forAll(rho, cellI)
+{
+    scalar& Nst = Neta[lowerN][cellI];
+
+    //find Nst index
+    if(Nst < NstList.first())
+    {
+        nlc[cellI] = 0;
+        nfc[cellI] = 0;
+    }
+    else if(Nst > NstList[NstList.size()-2])
+    {
+        nhc[cellI] = NstList.size()-2; //just before extinction
+        nfc[cellI] = 1;
+    }
+    else
+    {
+        nlc[cellI] = label( interpolateXY(Nst, NstList, NstIndex) );
+        nhc[cellI] = nlc[cellI]+1;
+        nfc[cellI] = (Nst-NstList[nlc[cellI]])
+                     /(NstList[nhc[cellI]]-NstList[nlc[cellI]]);
+    }
+
+    //update Favre mean temp. and rho(=1/RT)
+    scalar jl = jlc[cellI], jh = jhc[cellI];
+    scalar vl = vlc[cellI], vh = vhc[cellI];
+    scalar nl = nlc[cellI], nh = nhc[cellI];
+    scalar jfac = jfc[cellI], vfac = vfc[cellI], nfac = nfc[cellI];
+
+    scalar T00 = Ttable[jl][vl][nl]*(1-jfac)+Ttable[jh][vl][nl]*jfac;
+    scalar T01 = Ttable[jl][vl][nh]*(1-jfac)+Ttable[jh][vl][nh]*jfac;
+    scalar T10 = Ttable[jl][vh][nl]*(1-jfac)+Ttable[jh][vh][nl]*jfac;
+    scalar T11 = Ttable[jl][vh][nh]*(1-jfac)+Ttable[jh][vh][nh]*jfac;
+
+    scalar T0 = T00*(1-vfac)+T10*vfac;
+    scalar T1 = T01*(1-vfac)+T11*vfac;
+
+    T[cellI] = T0*(1-nfac)+T1*nfac;
+
+    scalar R00 = Rtable[jl][vl][nl]*(1-jfac)+Rtable[jh][vl][nl]*jfac;
+    scalar R01 = Rtable[jl][vl][nh]*(1-jfac)+Rtable[jh][vl][nh]*jfac;
+    scalar R10 = Rtable[jl][vh][nl]*(1-jfac)+Rtable[jh][vh][nl]*jfac;
+    scalar R11 = Rtable[jl][vh][nh]*(1-jfac)+Rtable[jh][vh][nh]*jfac;
+
+    scalar R0 = R00*(1-vfac)+R10*vfac;
+    scalar R1 = R01*(1-vfac)+R11*vfac;
+
+    scalar Rgas = R0*(1-nfac)+R1*nfac;
+    rho[cellI] = p[cellI]/(Rgas*T[cellI]);
+}
+
+//correct processor boundary value of T and rho
+T.correctBoundaryConditions();
+rho.correctBoundaryConditions();
+

applications/solvers/combustion/SLFMFoam/updateYi.H

@@ -0,0 +1,56 @@
+//force the saving of the old-time values
+//important!!
+
+forAll(rho, cellI)
+{
+    scalar& Nst = Neta[lowerN][cellI];
+
+    //find Nst index
+    if(Nst < NstList.first())
+    {
+        nlc[cellI] = 0;
+        nfc[cellI] = 0;
+    }
+    else if(Nst > NstList[NstList.size()-2])
+    {
+        nhc[cellI] = NstList.size()-2; //just before extinction
+        nfc[cellI] = 1;
+    }
+    else
+    {
+        nlc[cellI] = label( interpolateXY(Nst, NstList, NstIndex) );
+        nhc[cellI] = nlc[cellI]+1;
+        nfc[cellI] = (Nst-NstList[nlc[cellI]])
+                     /(NstList[nhc[cellI]]-NstList[nlc[cellI]]);
+    }
+
+    //update Favre mean temp. and rho(=1/RT)
+    scalar jl = jlc[cellI], jh = jhc[cellI];
+    scalar vl = vlc[cellI], vh = vhc[cellI];
+    scalar nl = nlc[cellI], nh = nhc[cellI];
+    scalar jfac = jfc[cellI], vfac = vfc[cellI], nfac = nfc[cellI];
+
+
+    forAll(Y, yi)
+    {
+        scalar y00 = Ytable[yi][jl][vl][nl]*(1-jfac)+Ytable[yi][jh][vl][nl]*jfac;
+        scalar y01 = Ytable[yi][jl][vl][nh]*(1-jfac)+Ytable[yi][jh][vl][nh]*jfac;
+        scalar y10 = Ytable[yi][jl][vh][nl]*(1-jfac)+Ytable[yi][jh][vh][nl]*jfac;
+        scalar y11 = Ytable[yi][jl][vh][nh]*(1-jfac)+Ytable[yi][jh][vh][nh]*jfac;
+
+        scalar y0 = y00*(1-vfac)+y10*vfac;
+        scalar y1 = y01*(1-vfac)+y11*vfac;
+
+        scalar ygas = y0*(1-nfac)+y1*nfac;
+
+        Y[yi][cellI] = ygas;
+    }
+}
+
+//correct processor boundary value of T and rho
+forAll(Y, yi)
+{
+    Y[yi].correctBoundaryConditions();
+}
+
+

src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.C

@@ -96,8 +96,7 @@ void Foam::ReactingParcel<ParcelType>::calcPhaseChange
         pc_,
         this->Tc_,
         X,
-        dMassPC,
+        dMassPC
-        this->rhoc_
     );
 
     // Limit phase change mass by availability of each specie

src/lagrangian/intermediate/parcels/include/makeReactingParcelPhaseChangeModels.H

@@ -30,7 +30,6 @@ License
 
 #include "NoPhaseChange.H"
 #include "LiquidEvaporation.H"
-#include "LiquidEvaporationConvDiff.H"
 #include "LiquidEvaporationBoil.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -40,7 +39,6 @@ License
     makePhaseChangeModel(CloudType);                                           \
     makePhaseChangeModelType(NoPhaseChange, CloudType);                        \
     makePhaseChangeModelType(LiquidEvaporation, CloudType);                    \
-    makePhaseChangeModelType(LiquidEvaporationConvDiff, CloudType);            \
     makePhaseChangeModelType(LiquidEvaporationBoil, CloudType);
 
 

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.C

@@ -142,8 +142,7 @@ void Foam::LiquidEvaporation<CloudType>::calculate
     const scalar pc,
     const scalar Tc,
     const scalarField& X,
-    scalarField& dMassPC,
+    scalarField& dMassPC
-    const scalar rhoc
 ) const
 {
     // immediately evaporate mass that has reached critical condition
@@ -197,8 +196,8 @@ void Foam::LiquidEvaporation<CloudType>::calculate
         // vapour concentration at surface [kmol/m3] at film temperature
         const scalar Cs = pSat/(RR*Ts);
 
-        // vapour concentration in bulk gas [kmol/m3] at bulk gas temperature
+        // vapour concentration in bulk gas [kmol/m3] at film temperature
-        const scalar Cinf = Xc[gid]*pc/(RR*Tc);
+        const scalar Cinf = Xc[gid]*pc/(RR*Ts);
 
         // molar flux of vapour [kmol/m2/s]
         const scalar Ni = max(kc*(Cs - Cinf), 0.0);

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporation/LiquidEvaporation.H

@@ -119,8 +119,7 @@ public:
             const scalar pc,
             const scalar Tc,
             const scalarField& X,
-            scalarField& dMassPC,
+            scalarField& dMassPC
-            const scalar rhoc
         ) const;
 
         //- Return the enthalpy per unit mass

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.C

@@ -142,8 +142,7 @@ void Foam::LiquidEvaporationBoil<CloudType>::calculate
     const scalar pc,
     const scalar Tc,
     const scalarField& X,
-    scalarField& dMassPC,
+    scalarField& dMassPC
-    const scalar rhoc
 ) const
 {
     // immediately evaporate mass that has reached critical condition

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationBoil/LiquidEvaporationBoil.H

@@ -129,8 +129,7 @@ public:
             const scalar pc,
             const scalar Tc,
             const scalarField& X,
-            scalarField& dMassPC,
+            scalarField& dMassPC
-            const scalar rhoc
         ) const;
 
         //- Return the enthalpy per unit mass

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationConvDiff/LiquidEvaporationConvDiff.C

@@ -1,287 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "LiquidEvaporationConvDiff.H"
-#include "specie.H"
-#include "mathematicalConstants.H"
-
-using namespace Foam::constant::mathematical;
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::tmp<Foam::scalarField> Foam::LiquidEvaporationConvDiff<CloudType>::calcXc
-(
-    const label celli
-) const
-{
-    scalarField Xc(this->owner().thermo().carrier().Y().size());
-
-    forAll(Xc, i)
-    {
-        Xc[i] =
-            this->owner().thermo().carrier().Y()[i][celli]
-           /this->owner().thermo().carrier().W(i);
-    }
-
-    return Xc/sum(Xc);
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::LiquidEvaporationConvDiff<CloudType>::Sh
-(
-    const scalar Re,
-    const scalar Sc
-) const
-{
-    return 2.0 + 0.6*Foam::sqrt(Re)*cbrt(Sc);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::LiquidEvaporationConvDiff<CloudType>::LiquidEvaporationConvDiff
-(
-    const dictionary& dict,
-    CloudType& owner
-)
-:
-    PhaseChangeModel<CloudType>(dict, owner, typeName),
-    liquids_(owner.thermo().liquids()),
-    activeLiquids_(this->coeffDict().lookup("activeLiquids")),
-    liqToCarrierMap_(activeLiquids_.size(), -1),
-    liqToLiqMap_(activeLiquids_.size(), -1)
-{
-    if (activeLiquids_.size() == 0)
-    {
-        WarningInFunction
-            << "Evaporation model selected, but no active liquids defined"
-            << nl << endl;
-    }
-    else
-    {
-        Info<< "Participating liquid species:" << endl;
-
-        // Determine mapping between liquid and carrier phase species
-        forAll(activeLiquids_, i)
-        {
-            Info<< "    " << activeLiquids_[i] << endl;
-            liqToCarrierMap_[i] =
-                owner.composition().carrierId(activeLiquids_[i]);
-        }
-
-        // Determine mapping between model active liquids and global liquids
-        const label idLiquid = owner.composition().idLiquid();
-        forAll(activeLiquids_, i)
-        {
-            liqToLiqMap_[i] =
-                owner.composition().localId(idLiquid, activeLiquids_[i]);
-        }
-    }
-}
-
-
-template<class CloudType>
-Foam::LiquidEvaporationConvDiff<CloudType>::LiquidEvaporationConvDiff
-(
-    const LiquidEvaporationConvDiff<CloudType>& pcm
-)
-:
-    PhaseChangeModel<CloudType>(pcm),
-    liquids_(pcm.owner().thermo().liquids()),
-    activeLiquids_(pcm.activeLiquids_),
-    liqToCarrierMap_(pcm.liqToCarrierMap_),
-    liqToLiqMap_(pcm.liqToLiqMap_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::LiquidEvaporationConvDiff<CloudType>::~LiquidEvaporationConvDiff()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-void Foam::LiquidEvaporationConvDiff<CloudType>::calculate
-(
-    const scalar dt,
-    const label celli,
-    const scalar Re,
-    const scalar Pr,
-    const scalar d,
-    const scalar nu,
-    const scalar T,
-    const scalar Ts,
-    const scalar pc,
-    const scalar Tc,
-    const scalarField& X,
-    scalarField& dMassPC, 
-    const scalar rhoc     //POSECH
-) const
-{
-    // immediately evaporate mass that has reached critical condition
-    if ((liquids_.Tc(X) - T) < SMALL)
-    {
-        if (debug)
-        {
-            WarningInFunction
-                << "Parcel reached critical conditions: "
-                << "evaporating all avaliable mass" << endl;
-        }
-
-        forAll(activeLiquids_, i)
-        {
-            const label lid = liqToLiqMap_[i];
-            dMassPC[lid] = GREAT;
-        }
-
-        return;
-    }
-
-    // construct carrier phase species volume fractions for cell, celli
-    const scalarField Xc(calcXc(celli));
-
-    // calculate mass transfer of each specie in liquid
-    forAll(activeLiquids_, i)
-    {
-        const label gid = liqToCarrierMap_[i];
-        const label lid = liqToLiqMap_[i];
-
-        // vapour diffusivity [m2/s]
-        const scalar Dab = liquids_.properties()[lid].D(pc, Ts);
-
-        // saturation pressure for species i [pa]
-        // - carrier phase pressure assumed equal to the liquid vapour pressure
-        //   close to the surface
-        // NOTE: if pSat > pc then particle is superheated
-        // calculated evaporation rate will be greater than that of a particle
-        // at boiling point, but this is not a boiling model
-        const scalar pSat = liquids_.properties()[lid].pv(pc, T);
-
-        // Schmidt number
-        const scalar Sc = nu/(Dab + ROOTVSMALL);
-
-        // Sherwood number
-        const scalar Sh = this->Sh(Re, Sc);
-
-        // mass transfer coefficient [m/s]
-        const scalar kc = Sh*Dab/(d + ROOTVSMALL);
-
-        // vapour concentration at surface [kmol/m3] at film temperature
-        const scalar Cs = pSat/(RR*Ts);
-
-        // vapour concentration in bulk gas [kmol/m3] at bulk gas temperature
-        const scalar Cinf = Xc[gid]*pc/(RR*Tc);
-
-        // molar flux of vapour [kmol/m2/s]
-        const scalar Ni = max(kc*(Cs - Cinf), 0.0);
-
-        // droplet surface pressure assumed to surface vapour pressure
-        const scalar ps = liquids_.pv(pc, Ts, X);
-
-        // vapour density at droplet surface [kg/m3]
-        const scalar rhos = ps*liquids_.W(X)/(RR*Ts);
-
-        // vapour mass fraction at surface
-        const scalar Ys = min((Cs*liquids_.W(X)/rhos),0.9);
-
-        // vapour mass fraction in bulk gas
-        const scalar Yinf = Cinf*liquids_.W(X)/rhos;
-
-        // Spalding mass number
-        const scalar Bm = max(((Ys - Yinf)/(1.0 - Ys)),0.0);
-
-        // mass transfer [kg]
-        dMassPC[lid] += kc*pi*sqr(d)*rhoc*log(1+Bm)*dt;
-
-    }
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::LiquidEvaporationConvDiff<CloudType>::dh
-(
-    const label idc,
-    const label idl,
-    const scalar p,
-    const scalar T
-) const
-{
-    scalar dh = 0;
-
-    typedef PhaseChangeModel<CloudType> parent;
-    switch (parent::enthalpyTransfer_)
-    {
-        case (parent::etLatentHeat):
-        {
-            dh = liquids_.properties()[idl].hl(p, T);
-            break;
-        }
-        case (parent::etEnthalpyDifference):
-        {
-            scalar hc = this->owner().composition().carrier().Ha(idc, p, T);
-            scalar hp = liquids_.properties()[idl].h(p, T);
-
-            dh = hc - hp;
-            break;
-        }
-        default:
-        {
-            FatalErrorInFunction
-                << "Unknown enthalpyTransfer type" << abort(FatalError);
-        }
-    }
-
-    return dh;
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::LiquidEvaporationConvDiff<CloudType>::Tvap
-(
-    const scalarField& X
-) const
-{
-    return liquids_.Tpt(X);
-}
-
-
-template<class CloudType>
-Foam::scalar Foam::LiquidEvaporationConvDiff<CloudType>::TMax
-(
-    const scalar p,
-    const scalarField& X
-) const
-{
-    return liquids_.pvInvert(p, X);
-}
-
-
-// ************************************************************************* //

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/LiquidEvaporationConvDiff/LiquidEvaporationConvDiff.H

@@ -1,157 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::LiquidEvaporationConvDiff
-
-Description
-    Liquid evaporation model
-    - uses ideal gas assumption
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef LiquidEvaporationConvDiff_H
-#define LiquidEvaporationConvDiff_H
-
-#include "PhaseChangeModel.H"
-#include "liquidMixtureProperties.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-/*---------------------------------------------------------------------------*\
-                     Class LiquidEvaporationConvDiff Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class CloudType>
-class LiquidEvaporationConvDiff
-:
-    public PhaseChangeModel<CloudType>
-{
-protected:
-
-    // Protected data
-
-        //- Global liquid properties data
-        const liquidMixtureProperties& liquids_;
-
-        //- List of active liquid names
-        List<word> activeLiquids_;
-
-        //- Mapping between liquid and carrier species
-        List<label> liqToCarrierMap_;
-
-        //- Mapping between local and global liquid species
-        List<label> liqToLiqMap_;
-
-
-    // Protected Member Functions
-
-        //- Sherwood number as a function of Reynolds and Schmidt numbers
-        scalar Sh(const scalar Re, const scalar Sc) const;
-
-        //- Calculate the carrier phase component volume fractions at celli
-        tmp<scalarField> calcXc(const label celli) const;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("liquidEvaporationConvDiff");
-
-
-    // Constructors
-
-        //- Construct from dictionary
-        LiquidEvaporationConvDiff(const dictionary& dict, CloudType& cloud);
-
-        //- Construct copy
-        LiquidEvaporationConvDiff(const LiquidEvaporationConvDiff<CloudType>& pcm);
-
-        //- Construct and return a clone
-        virtual autoPtr<PhaseChangeModel<CloudType>> clone() const
-        {
-            return autoPtr<PhaseChangeModel<CloudType>>
-            (
-                new LiquidEvaporationConvDiff<CloudType>(*this)
-            );
-        }
-
-
-    //- Destructor
-    virtual ~LiquidEvaporationConvDiff();
-
-
-    // Member Functions
-
-        //- Update model
-        virtual void calculate
-        (
-            const scalar dt,
-            const label celli,
-            const scalar Re,
-            const scalar Pr,
-            const scalar d,
-            const scalar nu,
-            const scalar T,
-            const scalar Ts,
-            const scalar pc,
-            const scalar Tc,
-            const scalarField& X,
-            scalarField& dMassPC,
-            const scalar rhoc
-        ) const;
-
-        //- Return the enthalpy per unit mass
-        virtual scalar dh
-        (
-            const label idc,
-            const label idl,
-            const scalar p,
-            const scalar T
-        ) const;
-
-        //- Return vapourisation temperature
-        virtual scalar Tvap(const scalarField& X) const;
-
-        //- Return maximum/limiting temperature
-        virtual scalar TMax(const scalar p, const scalarField& X) const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "LiquidEvaporationConvDiff.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/NoPhaseChange/NoPhaseChange.C

@@ -78,8 +78,7 @@ void Foam::NoPhaseChange<CloudType>::calculate
     const scalar pc,
     const scalar Tc,
     const scalarField& X,
-    scalarField& dMassPC,
+    scalarField& dMassPC
-    const scalar rhoc
 ) const
 {
     // Nothing to do...

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/NoPhaseChange/NoPhaseChange.H

@@ -94,8 +94,7 @@ public:
             const scalar pc,
             const scalar Tc,
             const scalarField& X,
-            scalarField& dMassPC,
+            scalarField& dMassPC
-            const scalar rhoc
         ) const;
 };
 

src/lagrangian/intermediate/submodels/Reacting/PhaseChangeModel/PhaseChangeModel/PhaseChangeModel.H

@@ -166,8 +166,7 @@ public:
             const scalar pc,
             const scalar Tc,
             const scalarField& X,
-            scalarField& dMassPC,
+            scalarField& dMassPC
-            const scalar rhoc
         ) const = 0;
 
         //- Return the enthalpy per unit mass

src/thermophysicalModels/reactionThermo/chemistryReaders/chemkinReader/chemkinLexer.L

@@ -148,7 +148,7 @@ irreversibleReactionDelimiter {space}"=>"{space}
 startPDependentSpecie {space}"("{space}"+"{space}
 pDependentSpecie      {specieName}")"{space}
 reactionCoeffs        {space}{floatNum}{some_space}{floatNum}{some_space}{floatNum}{space}
-reactionKeyword       {space}[A-Za-z](([A-Za-z0-9)*-])|("("[^+]))*((\+({some_space}))?){space}
+reactionKeyword       {space}[A-Za-z](([A-Za-z0-9)*-])|("("[^+]))*{space}
 reactionKeywordSlash  {reactionKeyword}"/"{space}
 thirdBodyEfficiency   {space}{floatNum}{space}"/"{space}
 startReactionCoeffs   {space}"/"{space}
@@ -637,8 +637,7 @@ bool finishReaction = false;
                     (
                         currentSpecieName,
                         1.0,
-                        molecularWeight(currentSpecieComposition),
+                        molecularWeight(currentSpecieComposition)
-                        chargeNumber(currentSpecieComposition)
                     ),
                     currentLowT,
                     currentHighT,

src/thermophysicalModels/reactionThermo/chemistryReaders/chemkinReader/chemkinReader.C

@@ -144,28 +144,6 @@ Foam::scalar Foam::chemkinReader::molecularWeight
 }
 
 
-Foam::scalar Foam::chemkinReader::chargeNumber
-(
-    const List<specieElement>& specieComposition
-) const
-{
-    scalar nElemCharges = 0.0;
-
-    forAll(specieComposition, i)
-    {
-        label nAtoms = specieComposition[i].nAtoms;
-        const word& elementName = specieComposition[i].elementName;
-
-        if (elementName[0] == 'e')
-        {
-            nElemCharges -= nAtoms;
-        }
-    }
-
-    return nElemCharges;
-}
-
-
 void Foam::chemkinReader::checkCoeffs
 (
     const scalarList& reactionCoeffs,

src/thermophysicalModels/reactionThermo/chemistryReaders/chemkinReader/chemkinReader.H

@@ -254,11 +254,6 @@ private:
             const List<specieElement>& specieComposition
         ) const;
 
-        scalar chargeNumber
-        (
-            const List<specieElement>& specieComposition
-        ) const;
-
         void finishElements(labelList& currentAtoms);
 
         void checkCoeffs

src/thermophysicalModels/reactionThermo/mixtures/SpecieMixture/SpecieMixture.C

@@ -68,70 +68,6 @@ Foam::scalar Foam::SpecieMixture<MixtureType>::W
 }
 
 
-template<class MixtureType>
-Foam::scalar Foam::SpecieMixture<MixtureType>::z
-(
-    const label speciei
-) const
-{
-    return this->getLocalThermo(speciei).z();
-}
-
-
-template<class MixtureType>
-Foam::scalar Foam::SpecieMixture<MixtureType>::Qc
-(
-    const label speciei
-) const
-{
-    return this->getLocalThermo(speciei).Qc();
-}
-
-
-template<class MixtureType>
-Foam::scalar Foam::SpecieMixture<MixtureType>::Qc2
-(
-    const label speciei
-) const
-{
-    return this->getLocalThermo(speciei).Qc2();
-}
-
-
-template<class MixtureType>
-void Foam::SpecieMixture<MixtureType>::Cp
-(
-    scalarField& Cps,
-    const scalar p,
-    const scalar T
-) const
-{
-    forAll(this->species(), speciei)
-    {
-        Cps[speciei] = this->getLocalThermo(speciei).Cp(p, T);
-    }
-
-    return;
-}
-
-
-template<class MixtureType>
-void Foam::SpecieMixture<MixtureType>::Cv
-(
-    scalarField& Cvs,
-    const scalar p,
-    const scalar T
-) const
-{
-    forAll(this->species(), speciei)
-    {
-        Cvs[speciei] = this->getLocalThermo(speciei).Cv(p, T);
-    }
-
-    return;
-}
-
-
 template<class MixtureType>
 Foam::scalar Foam::SpecieMixture<MixtureType>::Cp
 (

src/thermophysicalModels/reactionThermo/mixtures/SpecieMixture/SpecieMixture.H

@@ -81,34 +81,6 @@ public:
             //- Molecular weight of the given specie [kg/kmol]
             virtual scalar W(const label speciei) const;
 
-            //- Number of charges of the given specie []
-            virtual scalar z(const label speciei) const;
-
-            //- Specific charge of the given specie []
-            virtual scalar Qc(const label specieI) const;
-
-            //- Absolute specific charge of the given specie []
-            virtual scalar Qc2(const label specieI) const;
-
-
-        // All species thermo properties
-
-            //- Heat capacity at constant pressure [J/(kg K)]
-            virtual void Cp
-            (
-                scalarField& Cps,
-                const scalar p,
-                const scalar T
-            ) const;
-
-            //- Heat capacity at constant volume [J/(kg K)]
-            virtual void Cv
-            (
-                scalarField& Cvs,
-                const scalar p,
-                const scalar T
-            ) const;
-
 
         // Per specie thermo properties
 

src/thermophysicalModels/reactionThermo/mixtures/basicSpecieMixture/basicSpecieMixture.C

@@ -81,72 +81,4 @@ Foam::tmp<Foam::volScalarField> Foam::basicSpecieMixture::W() const
 }
 
 
-Foam::tmp<Foam::volScalarField> Foam::basicSpecieMixture::Qc() const
-{
-    const PtrList<volScalarField>& Y(basicMultiComponentMixture::Y());
-
-    tmp<volScalarField> tQc
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                IOobject::groupName("Qc", Y[0].group()),
-                Y[0].time().timeName(),
-                Y[0].mesh()
-            ),
-            Y[0].mesh(),
-            dimensionedScalar("zero", dimCurrent*dimTime/dimMass, 0)
-        )
-    );
-
-    volScalarField& Qc = tQc.ref();
-
-    dimensionedScalar Qci("Qci", dimCurrent*dimTime/dimMass, 0);
-
-    forAll(Y, i)
-    {
-        Qci.value() = this->Qc(i);
-        Qc += Y[i]*Qci;
-        // Qc += Y[i]*this->Qc(i);
-    }
-
-    return tQc;
-}
-
-
-Foam::tmp<Foam::volScalarField> Foam::basicSpecieMixture::Qc2() const
-{
-    const PtrList<volScalarField>& Y(basicMultiComponentMixture::Y());
-
-    tmp<volScalarField> tQc
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                IOobject::groupName("Qc2", Y[0].group()),
-                Y[0].time().timeName(),
-                Y[0].mesh()
-            ),
-            Y[0].mesh(),
-            dimensionedScalar("zero", sqr(dimCurrent*dimTime)/dimMass, 0)
-        )
-    );
-
-    volScalarField& Qc = tQc.ref();
-
-    dimensionedScalar Qc2i("Qc2i", sqr(dimCurrent*dimTime)/dimMass, 0);
-
-    forAll(Y, i)
-    {
-        Qc2i.value() = this->Qc2(i);
-        Qc += Y[i]*Qc2i;
-        //Qc += Y[i]*this->Qc2(i);
-    }
-
-    return tQc;
-}
-
-
 // ************************************************************************* //

src/thermophysicalModels/reactionThermo/mixtures/basicSpecieMixture/basicSpecieMixture.H

@@ -88,43 +88,9 @@ public:
             //- Molecular weight of the given specie [kg/kmol]
             virtual scalar W(const label speciei) const = 0;
 
-            //- Number of charges of the given specie []
-            virtual scalar z(const label speciei) const = 0;
-
-            //- Specific charge of the given specie [C/kg]
-            virtual scalar Qc(const label speciei) const = 0;
-
-            //- Absolute specific charge of the given specie [C/kg]
-            virtual scalar Qc2(const label speciei) const = 0;
-
             //- Molecular weight of the mixture [kg/kmol]
             tmp<volScalarField> W() const;
 
-            //- Specific charge of the mixture [C/kg]
-            tmp<volScalarField> Qc() const;
-
-            //- Absolute specific charge of the mixture [C^2/kg]
-            tmp<volScalarField> Qc2() const;
-
-
-        // All species thermo properties
-
-            //- Heat capacity at constant pressure [J/(kg K)]
-            virtual void Cp
-            (
-                scalarField& Cps,
-                const scalar p,
-                const scalar T
-            ) const = 0;
-
-            //- Heat capacity at constant volume [J/(kg K)]
-            virtual void Cv
-            (
-                scalarField& Cvs,
-                const scalar p,
-                const scalar T
-            ) const = 0;
-
 
         // Per specie thermo properties
 

src/thermophysicalModels/specie/specie/specie.C

@@ -29,24 +29,6 @@ License
 
 /* * * * * * * * * * * * * * * public constants  * * * * * * * * * * * * * * */
 
-//- Universal gas constant (default in [J/(kmol K)])
-const Foam::scalar Foam::specie::RR = constant::physicoChemical::R.value()*1000;
-
-//- Standard pressure (default in [Pa])
-const Foam::scalar Foam::specie::Pstd = constant::standard::Pstd.value();
-
-//- Standard temperature (default in [K])
-const Foam::scalar Foam::specie::Tstd = constant::standard::Tstd.value();
-
-//- Elementary charge (default in [C])
-const Foam::scalar Foam::specie::e = constant::electromagnetic::e.value();
-
-//- Avogadro number (default in [1/mol])
-const Foam::scalar Foam::specie::NA = constant::physicoChemical::NA.value()*1000;
-
-//- Boltzmann constant (default in [J/K])
-const Foam::scalar Foam::specie::k = constant::physicoChemical::k.value();
-
 namespace Foam
 {
     defineTypeNameAndDebug(specie, 0);
@@ -59,8 +41,7 @@ Foam::specie::specie(Istream& is)
 :
     name_(is),
     nMoles_(readScalar(is)),
-    molWeight_(readScalar(is)),
+    molWeight_(readScalar(is))
-    nCharges_(readScalar(is))
 {
     is.check("specie::specie(Istream& is)");
 }
@@ -70,8 +51,7 @@ Foam::specie::specie(const dictionary& dict)
 :
     name_(dict.dictName()),
     nMoles_(readScalar(dict.subDict("specie").lookup("nMoles"))),
-    molWeight_(readScalar(dict.subDict("specie").lookup("molWeight"))),
+    molWeight_(readScalar(dict.subDict("specie").lookup("molWeight")))
-    nCharges_(dict.subDict("specie").lookupOrDefault("nCharges", 0.0))
 {}
 
 
@@ -82,7 +62,6 @@ void Foam::specie::write(Ostream& os) const
     dictionary dict("specie");
     dict.add("nMoles", nMoles_);
     dict.add("molWeight", molWeight_);
-    dict.add("nCharges", nCharges_);
     os  << indent << dict.dictName() << dict;
 }
 
@@ -93,8 +72,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const specie& st)
 {
     os  << st.name_ << tab
         << st.nMoles_ << tab
-        << st.molWeight_ << tab
+        << st.molWeight_;
-        << st.nCharges_;
 
     os.check("Ostream& operator<<(Ostream& os, const specie& st)");
     return os;

src/thermophysicalModels/specie/specie/specie.H

@@ -77,9 +77,6 @@ class specie
         //- Molecular weight of specie [kg/kmol]
         scalar molWeight_;
 
-        //- Number of elementary charges of specie
-        scalar nCharges_;
-
 
 public:
 
@@ -87,29 +84,6 @@ public:
     ClassName("specie");
 
 
-    // Public constants
-
-        // Thermodynamic constants
-
-            //- Universal gas constant [J/(kmol K)]
-            static const scalar RR;
-
-            //- Standard pressure [Pa]
-            static const scalar Pstd;
-
-            //- Standard temperature [K]
-            static const scalar Tstd;
-
-            //- Elementary charge [C]
-            static const scalar e;
-
-            //- Avogadro number [1/kmol]
-            static const scalar NA;
-
-            //- Boltzmann constant [J/K]
-            static const scalar k;
-
-
     // Constructors
 
 
@@ -124,23 +98,6 @@ public:
             const scalar molWeight
         );
 
-        //- Construct from components without name
-        inline specie
-        (
-            const scalar nMoles,
-            const scalar molWeight,
-            const scalar nCharges
-        );
-
-        //- Construct from components with name
-        inline specie
-        (
-            const word& name,
-            const scalar nMoles,
-            const scalar molWeight,
-            const scalar nCharges
-        );
-
         //- Construct as copy
         inline specie(const specie&);
 
@@ -170,27 +127,6 @@ public:
             //- Gas constant [J/(kg K)]
             inline scalar R() const;
 
-            //- Charge number
-            inline scalar z() const;
-
-
-        // Electric charge function
-
-
-            // Mole specific properties
-
-                //- Electric charge [C/kmol]
-                inline scalar qc() const;
-
-
-            // Mass specific properties
-
-                //- Electric charge [C/kg]
-                inline scalar Qc() const;
-
-                //- Electric charge squared [C^2/kg]
-                inline scalar Qc2() const;
-
 
         // I-O
 

src/thermophysicalModels/specie/specie/specieI.H

@@ -41,8 +41,7 @@ inline specie::specie
 :
     name_(name),
     nMoles_(nMoles),
-    molWeight_(molWeight),
+    molWeight_(molWeight)
-    nCharges_(0.0)
 {}
 
 
@@ -53,36 +52,7 @@ inline specie::specie
 )
 :
     nMoles_(nMoles),
-    molWeight_(molWeight),
+    molWeight_(molWeight)
-    nCharges_(0.0)
-{}
-
-
-inline specie::specie
-(
-    const word& name,
-    const scalar nMoles,
-    const scalar molWeight,
-    const scalar nCharges
-)
-:
-    name_(name),
-    nMoles_(nMoles),
-    molWeight_(molWeight),
-    nCharges_(nCharges)
-{}
-
-
-inline specie::specie
-(
-    const scalar nMoles,
-    const scalar molWeight,
-    const scalar nCharges
-)
-:
-    nMoles_(nMoles),
-    molWeight_(molWeight),
-    nCharges_(nCharges)
 {}
 
 
@@ -92,8 +62,7 @@ inline specie::specie(const specie& st)
 :
     name_(st.name_),
     nMoles_(st.nMoles_),
-    molWeight_(st.molWeight_),
+    molWeight_(st.molWeight_)
-    nCharges_(st.nCharges_)
 {}
 
 
@@ -101,8 +70,7 @@ inline specie::specie(const word& name, const specie& st)
 :
     name_(name),
     nMoles_(st.nMoles_),
-    molWeight_(st.molWeight_),
+    molWeight_(st.molWeight_)
-    nCharges_(st.nCharges_)
 {}
 
 
@@ -132,30 +100,6 @@ inline scalar specie::R() const
 }
 
 
-inline scalar specie::z() const
-{
-    return nCharges_;
-}
-
-
-inline scalar specie::qc() const
-{
-    return nCharges_ * NA * e;
-}
-
-
-inline scalar specie::Qc() const
-{
-    return nCharges_ * NA * e / molWeight_;
-}
-
-
-inline scalar specie::Qc2() const
-{
-    return nCharges_ * nCharges_ * NA * e * e / molWeight_;
-}
-
-
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 inline void specie::operator=(const specie& st)
@@ -163,7 +107,6 @@ inline void specie::operator=(const specie& st)
     //name_ = st.name_;
     nMoles_ = st.nMoles_;
     molWeight_ = st.molWeight_;
-    nCharges_ = st.nCharges_;
 }
 
 
@@ -171,10 +114,6 @@ inline void specie::operator+=(const specie& st)
 {
     scalar sumNmoles = max(nMoles_ + st.nMoles_, SMALL);
 
-    nCharges_ =
-        nMoles_/sumNmoles*nCharges_
-      + st.nMoles_/sumNmoles*st.nCharges_;
-
     molWeight_ =
         nMoles_/sumNmoles*molWeight_
       + st.nMoles_/sumNmoles*st.molWeight_;
@@ -191,10 +130,6 @@ inline void specie::operator-=(const specie& st)
         diffnMoles = SMALL;
     }
 
-    nCharges_ =
-        nMoles_/diffnMoles*nCharges_
-      - st.nMoles_/diffnMoles*st.nCharges_;
-
     molWeight_ =
         nMoles_/diffnMoles*molWeight_
       - st.nMoles_/diffnMoles*st.molWeight_;
@@ -219,9 +154,7 @@ inline specie operator+(const specie& st1, const specie& st2)
     (
         sumNmoles,
         st1.nMoles_/sumNmoles*st1.molWeight_
-      + st2.nMoles_/sumNmoles*st2.molWeight_,
+      + st2.nMoles_/sumNmoles*st2.molWeight_
-        st1.nMoles_/sumNmoles*st1.nCharges_
-      + st2.nMoles_/sumNmoles*st2.nCharges_
     );
 }
 
@@ -238,9 +171,7 @@ inline specie operator-(const specie& st1, const specie& st2)
     (
         diffNmoles,
         st1.nMoles_/diffNmoles*st1.molWeight_
-      - st2.nMoles_/diffNmoles*st2.molWeight_,
+      - st2.nMoles_/diffNmoles*st2.molWeight_
-        st1.nMoles_/diffNmoles*st1.nCharges_
-      - st2.nMoles_/diffNmoles*st2.nCharges_
     );
 }
 
@@ -250,8 +181,7 @@ inline specie operator*(const scalar s, const specie& st)
     return specie
     (
         s*st.nMoles_,
-        st.molWeight_,
+        st.molWeight_
-        st.nCharges_
     );
 }
 

src/thermophysicalModels/specie/thermo/thermo/thermo.H

@@ -336,7 +336,6 @@ public:
             ) const;
 
 
-
         // I-O
 
             //- Write to Ostream

tutorials/combustion/SLFMFoam/FlameD/0/CH4

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          CH4;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0.155956;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/CO

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0/Fluid";
+    object          CO;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    axis
+    {
+        type            symmetryPlane;
+    }
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.00407;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/CO2

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          CO2;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.1098;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/H

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          H;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 2.48e-05;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/H2

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          H2;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.000129;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/H2O

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          H2O;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.0942;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/N2

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          N2;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0.767;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0.647382;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.7342;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0.767;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/NO

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          NO;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 4.8e-06;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/O

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          O;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.000747;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/O2

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0/Fluid";
+    object          O2;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0.233;
+
+boundaryField
+{
+    axis
+    {
+        type            symmetryPlane;
+    }
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0.196662;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.0540244;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0.233;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/OH

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0/Fluid";
+    object          OH;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    axis
+    {
+        type            symmetryPlane;
+    }
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.0028;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/T

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0/Fluid";
+    object          T;
+}
+
+dimensions      [ 0 0 0 1 0 0 0 ];
+
+internalField   uniform 200;
+
+boundaryField
+{
+    axis
+    {
+        type            symmetryPlane;
+    }
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 294;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 1880;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 291;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/U

@@ -0,0 +1,66 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volVectorField;
+    location        "0";
+    object          U;
+}
+
+dimensions      [ 0 1 -1 0 0 0 0 ];
+
+internalField   uniform ( 0 0 0 );
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform ( 0 49.6 0 );
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform ( 0 11.4 0 );
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform ( 0 0.9 0 );
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            fixedValue;
+        value           uniform ( 0 0 0 );
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/Ydefault

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          Ydefault;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/alphat

@@ -0,0 +1,66 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          alphat;
+}
+
+dimensions      [ 1 -1 -1 0 0 0 0 ];
+
+internalField   uniform 0.1;
+
+boundaryField
+{
+    mainjet
+    {
+        type            calculated;
+        value           uniform 0.1;
+    }
+    pilot
+    {
+        type            calculated;
+        value           uniform 0.1;
+    }
+    coflow
+    {
+        type            calculated;
+        value           uniform 0.1;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            compressible::alphatWallFunction;
+        value           uniform 0;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/epsilon

@@ -0,0 +1,69 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          epsilon;
+}
+
+dimensions      [ 0 2 -3 0 0 0 0 ];
+
+internalField   uniform 50;
+
+boundaryField
+{
+    mainjet
+    {
+        type            turbulentMixingLengthDissipationRateInlet;
+        mixingLength    0.000504;
+        value           uniform 200;
+    }
+    pilot
+    {
+        type            turbulentMixingLengthDissipationRateInlet;
+        mixingLength    0.000735;
+        value           uniform 200;
+    }
+    coflow
+    {
+        type            turbulentMixingLengthDissipationRateInlet;
+        mixingLength    0.0197;
+        value           uniform 200;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            epsilonWallFunction;
+        value           uniform 0;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/k

@@ -0,0 +1,69 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          k;
+}
+
+dimensions      [ 0 2 -2 0 0 0 0 ];
+
+internalField   uniform 1;
+
+boundaryField
+{
+    mainjet
+    {
+        type            turbulentIntensityKineticEnergyInlet;
+        intensity       0.0458;
+        value           uniform 1;
+    }
+    pilot
+    {
+        type            turbulentIntensityKineticEnergyInlet;
+        intensity       0.0628;
+        value           uniform 1;
+    }
+    coflow
+    {
+        type            turbulentIntensityKineticEnergyInlet;
+        intensity       0.0471;
+        value           uniform 1;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            kqRWallFunction;
+        value           uniform 0;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/mf

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          mf;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 1;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0.27;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/mfVar

@@ -0,0 +1,65 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          mfVar;
+}
+
+dimensions      [ 0 0 0 0 0 0 0 ];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    mainjet
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    coflow
+    {
+        type            fixedValue;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/nut

@@ -0,0 +1,66 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          mut;
+}
+
+dimensions      [ 0 2 -1 0 0 0 0 ];
+
+internalField   uniform 0.1;
+
+boundaryField
+{
+    mainjet
+    {
+        type            calculated;
+        value           uniform 0;
+    }
+    pilot
+    {
+        type            calculated;
+        value           uniform 0;
+    }
+    coflow
+    {
+        type            calculated;
+        value           uniform 0;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    burnerwall
+    {
+        type            nutkWallFunction;
+        value           uniform 0;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/0/p

@@ -0,0 +1,63 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version         2;
+    format          ascii;
+    class           volScalarField;
+    location        "0";
+    object          p;
+}
+
+dimensions      [ 1 -1 -2 0 0 0 0 ];
+
+internalField   uniform 100616;
+
+boundaryField
+{
+    mainjet
+    {
+        type            zeroGradient;
+    }
+    pilot
+    {
+        type            zeroGradient;
+    }
+    coflow
+    {
+        type            zeroGradient;
+    }
+    outlet
+    {
+        type            fixedValue;
+        value           uniform 100616;
+    }
+    burnerwall
+    {
+        type            zeroGradient;
+    }
+    slipwall
+    {
+        type            slip;
+    }
+    axis
+    {
+        type            symmetryPlane;
+    }
+    front
+    {
+        type            wedge;
+    }
+    back
+    {
+        type            wedge;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/constant/SLFMdict

@@ -0,0 +1,57 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.0                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      combustionProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+postSpecieNames (CO OH); //names of species for post-processing
+stoiMF 0.351; //stoichiometric mixture fraction
+stretchFactor 1.05;
+lowerN 20; //number of eta-space under stoichiometric value
+upperN 30; //number of eta-space over stoichiometric value
+
+Equilibrium false;
+NVar 40; //20;
+
+Sc 0.68; //Schmidt number
+outletName outlet; // outletName
+
+detailedEta
+(
+1e-6 1e-5 1e-4 1e-3 1e-2 
+0.1 0.9 
+0.99 0.999 0.9999 0.99999 0.999999
+);
+
+detailedN
+(
+10 10 10 10 10
+100
+10 10 10 10 10
+);
+
+NstFolder slfm_lib; //folder name of SLFM library
+NstList //list of Nst
+
+(
+1 3 5 10 15 20 25 30 35 40 
+45 50 55 60 65 70 75 80 85 90 
+95 100 105 110 115 120 125 130 135 140
+145 150 155 160 165 170 175 180 185 190
+195 200 205 210 215 220 225 230 235 240
+245 250 255 260 265 270 275 280 285 290
+293
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

tutorials/combustion/SLFMFoam/FlameD/constant/chemistryProperties

@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.0                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      chemistryProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+chemistryType
+{
+    chemistrySolver   ode; //EulerImplicit;
+    chemistryThermo   rho;
+}
+
+chemistry           off;
+
+initialChemicalTimeStep 1e-07;
+
+EulerImplicitCoeffs
+{
+    cTauChem        1;
+    equilibriumRateLimiter off;
+}
+
+odeCoeffs
+{
+    solver          SIBS; //seulex; //Rosenbrock34; //Rosenbrock43;
+    eps             0.05;
+    //absTol          1e-12;
+    //relTol          0.01;
+}
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/constant/combustionProperties

@@ -0,0 +1,46 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.0                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      combustionProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+combustionModel  laminar<rhoChemistryCombustion>;
+
+active  false;
+
+laminarCoeffs
+{
+}
+
+
+EDCCoeffs
+{
+    // EDC for RANS/URANS
+    underRelaxFineStructures            1.0;
+    CD1                                 2.1377;
+    CD2                                 2.45;
+    CD3                                 0.01;
+    gammaStarClipFactor                 0.5;
+
+    // Limiting temperature
+    TMin                                290;
+    TMax                                3000;
+
+    // tolerancies
+    absoluteTolerance                   1e-5;
+    relativeTolerance                   1e-5;
+
+    // maxIterations:
+    maxIterations                       1e+5;
+}

tutorials/combustion/SLFMFoam/FlameD/constant/g

@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.7.1                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       uniformDimensionedVectorField;
+    location    "constant";
+    object      g;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -2 0 0 0 0];
+value           ( 0 0 0 );
+
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/constant/polyMesh/blockMeshDict

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.7.1                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 0.001;
+
+vertices
+(
+
+(0 0 0)
+(0 576 0)
+(-0.15702979454  0 3.5965736)
+(-0.15702979454  576 3.5965736)
+(-0.167934643323 0 3.8463357)
+(-0.167934643323 576 3.8463357)
+(-0.396936424116 0 9.0913388)
+(-0.396936424116 576 9.0913388)
+(-0.412203210667 0 9.4410057)
+(-0.412203210667 576 9.4410057)
+(-6.5429081      0 149.8572332)
+(-6.5429081      576 149.8572332)
+(0.15702979454  0 3.5965736)
+(0.15702979454  576 3.5965736)
+(0.167934643323 0 3.8463357)
+(0.167934643323 576 3.8463357)
+(0.396936424116 0 9.0913388)
+(0.396936424116 576 9.0913388)
+(0.412203210667 0 9.4410057)
+(0.412203210667 576 9.4410057)
+(6.5429081      0 149.8572332)
+(6.5429081      576 149.8572332)
+);
+
+blocks
+(
+
+    hex (0 1 3 2 0 1 13 12) (150 10 1) simpleGrading (5 1 1)
+    hex (2 3 5 4 12 13 15 14) (150 1 1) simpleGrading (5 1 1)
+    hex (4 5 7 6 14 15 17 16) (150 15 1) simpleGrading (5 1 1)
+    hex (6 7 9 8 16 17 19 18) (150 1 1) simpleGrading (5 1 1)
+    hex (8 9 11 10 18 19 21 20) (150 80 1) simpleGrading (5 5 1)
+
+);
+
+edges
+(
+/*
+    arc 2 12 (0 3.6 0)
+    arc 3 13 (576 3.6 0)
+    arc 4 14 (0 3.85 0)
+    arc 5 15 (576 3.85 0)
+    arc 6 16 (0 9.1 0)
+    arc 7 17 (576 9.1 0)
+    arc 8 18 (0 9.45 0)
+    arc 9 19 (576 9.45 0)
+    arc 10 20 (0 150 0)
+    arc 11 21 (576 150 0)
+*/
+);
+
+patches
+(
+    symmetryPlane axis
+    (
+	(0 1 1 0)
+    )
+    patch mainjet
+    (
+        (0 2 12 0)
+    )
+    patch pilot
+    (
+        (4 6 16 14)
+    )
+    patch coflow
+    (
+        (8 10 20 18)
+    )
+    patch outlet
+    (
+	(1 3 13 1)
+	(3 5 15 13)
+	(5 7 17 15)
+	(7 9 19 17)
+	(9 11 21 19)
+    )
+    wall burnerwall
+    (
+	(2 4 14 12)
+	(6 8 18 16)
+    )
+    wall slipwall
+    (
+	(10 11 21 20)
+    )
+    wedge front
+    (
+        (0 1 13 12)
+        (12 13 15 14)
+        (14 15 17 16)
+        (16 17 19 18)
+        (18 19 21 20)
+    )
+    wedge back
+    (
+        (0 1 3 2)
+	(2 3 5 4)
+	(4 5 7 6)
+	(6 7 9 8)
+	(8 9 11 10)
+    )
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //

tutorials/combustion/SLFMFoam/FlameD/constant/polyMesh/boundary

@@ -0,0 +1,81 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.x                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       polyBoundaryMesh;
+    location    "constant/polyMesh";
+    object      boundary;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+9
+(
+    axis
+    {
+        type            symmetryPlane;
+        inGroups        1(symmetryPlane);
+        nFaces          0;
+        startFace       31843;
+    }
+    mainjet
+    {
+        type            patch;
+        nFaces          10;
+        startFace       31843;
+    }
+    pilot
+    {
+        type            patch;
+        nFaces          15;
+        startFace       31853;
+    }
+    coflow
+    {
+        type            patch;
+        nFaces          80;
+        startFace       31868;
+    }
+    outlet
+    {
+        type            patch;
+        nFaces          107;
+        startFace       31948;
+    }
+    burnerwall
+    {
+        type            wall;
+        inGroups        1(wall);
+        nFaces          2;
+        startFace       32055;
+    }
+    slipwall
+    {
+        type            wall;
+        inGroups        1(wall);
+        nFaces          150;
+        startFace       32057;
+    }
+    front
+    {
+        type            wedge;
+        inGroups        1(wedge);
+        nFaces          16050;
+        startFace       32207;
+    }
+    back
+    {
+        type            wedge;
+        inGroups        1(wedge);
+        nFaces          16050;
+        startFace       48257;
+    }
+)
+
+// ************************************************************************* //