Merge branch 'master' of /home/noisy3/OpenFOAM/OpenFOAM-dev

applications/solvers/combustion/PDRFoam/Make/options

@@ -15,8 +15,7 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
     -lengine \

applications/solvers/combustion/fireFoam/Allwclean

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wclean libso combustionModels
+wclean all sensibleEnthalpyCombustionThermophysicalModels
+wclean
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/combustion/fireFoam/Allwmake

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+sensibleEnthalpyCombustionThermophysicalModels/Allwmake
+wmake libso combustionModels
+wmake
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/combustion/fireFoam/Make/files

@@ -0,0 +1,4 @@
+fireFoam.C
+
+EXE = $(FOAM_APPBIN)/fireFoam
+

applications/solvers/combustion/fireFoam/Make/options

@@ -0,0 +1,23 @@
+EXE_INC = \
+    -I./combustionModels/lnInclude \
+    -I./sensibleEnthalpyCombustionThermophysicalModels/basic/lnInclude \
+    -I./sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude
+
+
+EXE_LIBS = \
+    -lbasicSensibleEnthalpyThermophysicalModels \
+    -lreactionSensibleEnthalpyThermophysicalModels \
+    -lcombustionModels \
+    -lspecie \
+    -lreactionThermophysicalModels \
+    -lbasicThermophysicalModels \
+    -lfiniteVolume \
+    -lcompressibleLESModels \
+    -lcompressibleRASModels \
+    -lradiation

applications/solvers/combustion/fireFoam/UEqn.H

@@ -0,0 +1,36 @@
+fvVectorMatrix UEqn
+(
+    fvm::ddt(rho, U)
+  + fvm::div(phi, U)
+  + turbulence->divDevRhoReff(U)
+);
+
+UEqn.relax();
+
+if (oCorr == nOuterCorr - 1)
+{
+    solve
+    (
+        UEqn
+      ==
+        fvc::reconstruct
+        (
+            fvc::interpolate(rho)*(g & mesh.Sf())
+          - fvc::snGrad(p)*mesh.magSf()
+        ),
+        mesh.solver("UFinal")
+    );
+}
+else
+{
+    solve
+    (
+        UEqn
+      ==
+        fvc::reconstruct
+        (
+            fvc::interpolate(rho)*(g & mesh.Sf())
+          - fvc::snGrad(p)*mesh.magSf()
+        )
+    );
+}

applications/solvers/combustion/fireFoam/combustionModels/Make/files

@@ -0,0 +1,9 @@
+combustionModel/combustionModel.C
+combustionModel/newCombustionModel.C
+
+infinitelyFastChemistry/infinitelyFastChemistry.C
+
+noCombustion/noCombustion.C
+
+LIB = $(FOAM_LIBBIN)/libcombustionModels
+

applications/solvers/combustion/fireFoam/combustionModels/Make/options

@@ -0,0 +1,11 @@
+EXE_INC = \
+    -I../sensibleEnthalpyCombustionThermophysicalModels/basic/lnInclude \
+    -I../sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(FOAM_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(FOAM_SRC)/finiteVolume/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume

applications/solvers/combustion/fireFoam/combustionModels/combustionModel/combustionModel.C

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "combustionModel.H"
+#include "fvm.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(combustionModel, 0);
+    defineRunTimeSelectionTable(combustionModel, dictionary);
+};
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::combustionModel::combustionModel
+(
+    const dictionary& combustionProperties,
+    const hsCombustionThermo& thermo,
+    const compressible::turbulenceModel& turbulence,
+    const surfaceScalarField& phi,
+    const volScalarField& rho
+)
+:
+    combustionModelCoeffs_
+    (
+        combustionProperties.subDict
+        (
+            word(combustionProperties.lookup("combustionModel")) + "Coeffs"
+        )
+    ),
+    thermo_(thermo),
+    turbulence_(turbulence),
+    mesh_(phi.mesh()),
+    phi_(phi),
+    rho_(rho),
+    stoicRatio_(thermo.lookup("stoichiometricAirFuelMassRatio")),
+    s_(thermo.lookup("stoichiometricOxygenFuelMassRatio")),
+    qFuel_(thermo_.lookup("qFuel")),
+    composition_(thermo.composition())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::combustionModel::~combustionModel()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::fvScalarMatrix>
+Foam::combustionModel::combustionModel::R(volScalarField& fu) const
+{
+    const basicMultiComponentMixture& composition = thermo_.composition();
+    const volScalarField& ft = composition.Y("ft");
+    volScalarField fres = composition.fres(ft, stoicRatio_.value());
+    volScalarField wFuelNorm = this->wFuelNorm()*pos(fu - fres);
+
+    return wFuelNorm*fres - fvm::Sp(wFuelNorm, fu);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::combustionModel::combustionModel::dQ
+(
+    const fvScalarMatrix& Rfu
+) const
+{
+    const basicMultiComponentMixture& composition = thermo_.composition();
+    const volScalarField& fu = composition.Y("fu");
+
+    return (-qFuel_)*(Rfu & fu);
+}
+
+
+bool Foam::combustionModel::read(const dictionary& combustionProperties)
+{
+    combustionModelCoeffs_ = combustionProperties.subDict(type() + "Coeffs");
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/combustionModel/combustionModel.H

@@ -0,0 +1,210 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::combustionModel
+
+Description
+    Base class for all non-premixed combustion models.
+
+SourceFiles
+    combustionModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef combustionModel_H
+#define combustionModel_H
+
+#include "IOdictionary.H"
+#include "hsCombustionThermo.H"
+#include "turbulenceModel.H"
+#include "multivariateSurfaceInterpolationScheme.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class combustionModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class combustionModel
+{
+
+protected:
+
+    // Protected data
+
+        //- Dictionary of coefficients for the particular model
+        dictionary combustionModelCoeffs_;
+
+        //- Reference to the thermodynamic
+        const hsCombustionThermo& thermo_;
+
+        //- Reference to the turbulence model
+        const compressible::turbulenceModel& turbulence_;
+
+        //- Reference to the mesh database
+        const fvMesh& mesh_;
+
+        //- Reference to mass-flux field
+        const surfaceScalarField& phi_;
+
+        //- Reference to the density field
+        const volScalarField& rho_;
+
+        //- Stoichiometric air-fuel mass ratio
+        dimensionedScalar stoicRatio_;
+
+        //- Stoichiometric oxygen-fuel mass ratio
+        dimensionedScalar s_;
+
+        //- Heat of combustion (J/Kg)
+        dimensionedScalar qFuel_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        combustionModel(const combustionModel&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const combustionModel&);
+
+        const basicMultiComponentMixture& composition_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("combustionModel");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            combustionModel,
+            dictionary,
+            (
+                const dictionary& combustionProperties,
+                const hsCombustionThermo& thermo,
+                const compressible::turbulenceModel& turbulence,
+                const surfaceScalarField& phi,
+                const volScalarField& rho
+            ),
+            (
+                combustionProperties,
+                thermo,
+                turbulence,
+                phi,
+                rho
+            )
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected combustion model
+        static autoPtr<combustionModel> New
+        (
+            const dictionary& combustionProperties,
+            const hsCombustionThermo& thermo,
+            const compressible::turbulenceModel& turbulence,
+            const surfaceScalarField& phi,
+            const volScalarField& rho
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        combustionModel
+        (
+            const dictionary& combustionProperties,
+            const hsCombustionThermo& thermo,
+            const compressible::turbulenceModel& turbulence,
+            const surfaceScalarField& phi,
+            const volScalarField& rho
+        );
+
+
+    //- Destructor
+    virtual ~combustionModel();
+
+
+    // Member Functions
+
+        // Access functions
+
+            //- Access composition
+            const basicMultiComponentMixture& composition() const
+            {
+                return composition_;
+            }
+
+            //- Access combustion dictionary
+            const dictionary combustionModelCoeffs() const
+            {
+                return combustionModelCoeffs_;
+            }
+
+            //- Access heat of combustion
+            const dimensionedScalar qFuel() const
+            {
+                return qFuel_;
+            }
+
+        //- Return normalised consumption rate of (fu - fres)
+        virtual tmp<volScalarField> wFuelNorm() const = 0;
+
+        //- Fuel consumption rate matrix i.e. source-term for the fuel equation
+        virtual tmp<fvScalarMatrix> R(volScalarField& fu) const;
+
+        //- Heat-release rate calculated from the given
+        //  fuel consumption rate matrix
+        virtual tmp<volScalarField> dQ(const fvScalarMatrix& Rfu) const;
+
+        //- Correct combustion rate
+        virtual void correct() = 0;
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& combustionProperties) = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/combustionModel/newCombustionModel.C

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "combustionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::combustionModel> Foam::combustionModel::New
+(
+    const dictionary& combustionProperties,
+    const hsCombustionThermo& thermo,
+    const compressible::turbulenceModel& turbulence,
+    const surfaceScalarField& phi,
+    const volScalarField& rho
+)
+{
+    word combustionModelTypeName = combustionProperties.lookup
+    (
+        "combustionModel"
+    );
+
+    Info<< "Selecting combustion model " << combustionModelTypeName << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(combustionModelTypeName);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "combustionModel::New"
+        )   << "Unknown combustionModel type "
+            << combustionModelTypeName << endl << endl
+            << "Valid  combustionModels are : " << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<combustionModel>
+        (cstrIter()(combustionProperties, thermo, turbulence, phi, rho));
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/infinitelyFastChemistry/infinitelyFastChemistry.C

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "infinitelyFastChemistry.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace combustionModels
+{
+    defineTypeNameAndDebug(infinitelyFastChemistry, 0);
+    addToRunTimeSelectionTable
+    (
+        combustionModel,
+        infinitelyFastChemistry,
+        dictionary
+    );
+};
+};
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::combustionModels::infinitelyFastChemistry::infinitelyFastChemistry
+(
+    const dictionary& combustionProperties,
+    const hsCombustionThermo& thermo,
+    const compressible::turbulenceModel& turbulence,
+    const surfaceScalarField& phi,
+    const volScalarField& rho
+)
+:
+    combustionModel(combustionProperties, thermo, turbulence, phi, rho),
+    C_(readScalar(combustionModelCoeffs_.lookup("C")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::combustionModels::infinitelyFastChemistry::~infinitelyFastChemistry()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::combustionModels::infinitelyFastChemistry::correct()
+{}
+
+
+Foam::tmp<Foam::volScalarField>
+Foam::combustionModels::infinitelyFastChemistry::wFuelNorm() const
+{
+    return rho_/(mesh_.time().deltaT()*C_);
+}
+
+
+bool Foam::combustionModels::infinitelyFastChemistry::read
+(
+    const dictionary& combustionProperties
+)
+{
+    combustionModel::read(combustionProperties);
+    combustionModelCoeffs_.lookup("C") >> C_ ;
+
+    return true;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/infinitelyFastChemistry/infinitelyFastChemistry.H

@@ -0,0 +1,119 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::combustionModels::infinitelyFastChemistry
+
+Description
+    Simple infinitely fast chemistry combustion model based on the principle
+    mixed is burnt. Additional parameter C is used to distribute the heat
+    release rate.in time
+
+SourceFiles
+    infinitelyFastChemistry.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef infinitelyFastChemistry_H
+#define infinitelyFastChemistry_H
+
+#include "fvc.H"
+#include "combustionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace combustionModels
+{
+
+/*---------------------------------------------------------------------------*\
+                Class infinitelyFastChemistry Declaration
+\*---------------------------------------------------------------------------*/
+
+class infinitelyFastChemistry
+:
+    public combustionModel
+{
+    // Private data
+
+        //- Model constant
+        scalar C_;
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        infinitelyFastChemistry(const infinitelyFastChemistry&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const infinitelyFastChemistry&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("infinitelyFastChemistry");
+
+
+    // Constructors
+
+        //- Construct from components
+        infinitelyFastChemistry
+        (
+            const dictionary& combustionProperties,
+            const hsCombustionThermo& thermo,
+            const compressible::turbulenceModel& turbulence,
+            const surfaceScalarField& phi,
+            const volScalarField& rho
+        );
+
+
+    // Destructor
+
+        virtual ~infinitelyFastChemistry();
+
+
+    // Member Functions
+
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& combustionProperties);
+
+        //- Correct combustion rate
+        virtual void correct();
+
+        //- Return normalised consumption rate of (fu - fres)
+        virtual tmp<volScalarField> wFuelNorm() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace combustionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/noCombustion/noCombustion.C

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "noCombustion.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace combustionModels
+{
+    defineTypeNameAndDebug(noCombustion, 0);
+    addToRunTimeSelectionTable
+    (
+        combustionModel,
+        noCombustion,
+        dictionary
+    );
+};
+};
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::combustionModels::noCombustion::noCombustion
+(
+    const dictionary& combustionProperties,
+    const hsCombustionThermo& thermo,
+    const compressible::turbulenceModel& turbulence,
+    const surfaceScalarField& phi,
+    const volScalarField& rho
+)
+:
+    combustionModel(combustionProperties, thermo, turbulence, phi, rho)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+Foam::combustionModels::noCombustion::~noCombustion()
+{}
+
+
+void Foam::combustionModels::noCombustion::correct()
+{}
+
+
+Foam::tmp<Foam::volScalarField>
+Foam::combustionModels::noCombustion::wFuelNorm() const
+{
+    return tmp<Foam::volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "wFuelNorm",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("wFuelNorm", dimMass/dimTime/pow3(dimLength), 0.0)
+        )
+    );
+}
+
+
+bool Foam::combustionModels::noCombustion::read
+(
+    const dictionary& combustionProperties
+)
+{
+    return combustionModel::read(combustionProperties);
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/combustionModels/noCombustion/noCombustion.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,67 +23,87 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::functionEntries::calcEntry
+    Foam::combustionModel::noCombustion
 
 Description
-    This dictionary function entry may or may not do anything particularly
-    useful - depending upon what is currently being used to test.
+    No combustion
 
 SourceFiles
-    calcEntry.C
+    noCombustion.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef calcEntry_H
-#define calcEntry_H
+#ifndef noCombustion_H
+#define noCombustion_H
 
-#include "functionEntry.H"
+#include "combustionModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-namespace functionEntries
+namespace combustionModels
 {
 
 /*---------------------------------------------------------------------------*\
-                          Class calcEntry Declaration
+                          Class noCombustion Declaration
 \*---------------------------------------------------------------------------*/
 
-class calcEntry
+class noCombustion
 :
-    public functionEntry
+    public combustionModel
 {
+    // Private data
+
+
     // Private Member Functions
 
-        //- Disallow default bitwise copy construct
-        calcEntry(const calcEntry&);
+        //- Disallow copy construct
+        noCombustion(const noCombustion&);
 
         //- Disallow default bitwise assignment
-        void operator=(const calcEntry&);
+        void operator=(const noCombustion&);
 
 
 public:
 
     //- Runtime type information
-    ClassName("calc");
+    TypeName("noCombustion");
 
 
+    // Constructors
+
+        //- Construct from components
+        noCombustion
+        (
+            const dictionary& combustionProperties,
+            const hsCombustionThermo& thermo,
+            const compressible::turbulenceModel& turbulence,
+            const surfaceScalarField& phi,
+            const volScalarField& rho
+        );
+
+
+    // Destructor
+
+        virtual ~noCombustion();
+
     // Member Functions
 
-        static bool execute
-        (
-            const dictionary& parentDict,
-            primitiveEntry& entry,
-            Istream& is
-        );
+        //- Update properties from given dictionary
+        virtual bool read(const dictionary& combustionProperties);
 
+        //- Correct combustion rate
+        virtual void correct();
+
+        //- Return normalised consumption rate of (fu - fres)
+        virtual tmp<volScalarField> wFuelNorm() const;
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace functionEntries
+} // End namespace combustionModels
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/solvers/combustion/fireFoam/createFields.H

@@ -0,0 +1,130 @@
+Info<< "Reading thermophysical properties\n" << endl;
+
+autoPtr<hsCombustionThermo> pThermo
+(
+    hsCombustionThermo::New(mesh)
+);
+
+hsCombustionThermo& thermo = pThermo();
+
+basicMultiComponentMixture& composition = thermo.composition();
+
+volScalarField rho
+(
+    IOobject
+    (
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
+
+dimensionedScalar stoicRatio
+(
+    thermo.lookup("stoichiometricAirFuelMassRatio")
+);
+
+volScalarField& p = thermo.p();
+volScalarField& hs = thermo.hs();
+
+const volScalarField& psi = thermo.psi();
+
+volScalarField& ft = composition.Y("ft");
+volScalarField& fu = composition.Y("fu");
+
+Info<< "Reading field U\n" << endl;
+
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New(rho, U, phi, thermo)
+);
+
+IOdictionary combustionProperties
+(
+    IOobject
+    (
+        "combustionProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    )
+);
+
+Info<< "Creating combustion model\n" << endl;
+autoPtr<combustionModel::combustionModel> combustion
+(
+    combustionModel::combustionModel::New
+    (
+        combustionProperties,
+        thermo,
+        turbulence(),
+        phi,
+        rho
+    )
+);
+
+volScalarField dQ
+(
+    IOobject
+    (
+        "dQ",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("dQ", dimMass/pow3(dimTime)/dimLength, 0.0)
+);
+
+
+Info<< "Creating field DpDt\n" << endl;
+volScalarField DpDt =
+    fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);
+
+
+Info<< "Calculating field g.h\n" << endl;
+volScalarField gh("gh", g & mesh.C());
+
+surfaceScalarField ghf("gh", g & mesh.Cf());
+
+p += rho*gh;
+
+thermo.correct();
+
+dimensionedScalar initialMass = fvc::domainIntegrate(rho);
+
+
+multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
+
+if (composition.contains("ft"))
+{
+    fields.add(composition.Y("ft"));
+}
+
+if (composition.contains("fu"))
+{
+    fields.add(composition.Y("fu"));
+}
+
+fields.add(hs);

applications/solvers/combustion/fireFoam/fireFoam.C

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+    fireFoam
+
+Description
+    Transient Solver for Fires and turbulent diffusion flames
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "hsCombustionThermo.H"
+#include "turbulenceModel.H"
+#include "combustionModel.H"
+
+#include "radiationModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "readGravitationalAcceleration.H"
+    #include "initContinuityErrs.H"
+    #include "createFields.H"
+    #include "createRadiationModel.H"
+    #include "readTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readPISOControls.H"
+        #include "readTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        #include "rhoEqn.H"
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        for (int oCorr=0; oCorr<nOuterCorr; oCorr++)
+        {
+            #include "UEqn.H"
+
+            #include "ftEqn.H"
+            #include "fuhsEqn.H"
+
+            // --- PISO loop
+            for (int corr=0; corr<nCorr; corr++)
+            {
+                #include "pEqn.H"
+            }
+        }
+
+        turbulence->correct();
+
+        rho = thermo.rho();
+
+        runTime.write();
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/ftEqn.H

@@ -0,0 +1,25 @@
+tmp<fv::convectionScheme<scalar> > mvConvection
+(
+    fv::convectionScheme<scalar>::New
+    (
+        mesh,
+        fields,
+        phi,
+        mesh.divScheme("div(phi,ft_b_h)")
+    )
+);
+
+{
+    fvScalarMatrix ftEqn
+    (
+        fvm::ddt(rho, ft)
+      + mvConvection->fvmDiv(phi, ft)
+      - fvm::laplacian(turbulence->alphaEff(), ft)
+    );
+
+    ftEqn.relax();
+    ftEqn.solve();
+}
+
+Info<< "max(ft) = " << max(ft).value() << endl;
+Info<< "min(ft) = " << min(ft).value() << endl;

applications/solvers/combustion/fireFoam/fuhsEqn.H

@@ -0,0 +1,47 @@
+{
+    // Solve fuel equation
+    // ~~~~~~~~~~~~~~~~~~~
+    fvScalarMatrix R = combustion->R(fu);
+
+    {
+        fvScalarMatrix fuEqn
+        (
+            fvm::ddt(rho, fu)
+          + mvConvection->fvmDiv(phi, fu)
+          - fvm::laplacian(turbulence->alphaEff(), fu)
+         ==
+            R
+        );
+
+        fuEqn.relax();
+        fuEqn.solve();
+    }
+
+    Info<< "max(fu) = " << max(fu).value() << endl;
+    Info<< "min(fu) = " << min(fu).value() << endl;
+
+
+    // Solve sensible enthalpy equation
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    radiation->correct();
+    dQ = combustion->dQ(R);
+
+    {
+        fvScalarMatrix hsEqn
+        (
+            fvm::ddt(rho, hs)
+          + mvConvection->fvmDiv(phi,hs)
+          - fvm::laplacian(turbulence->alphaEff(), hs)
+         ==
+            DpDt
+          + dQ
+          + radiation->Shs(thermo)
+        );
+
+        hsEqn.relax();
+        hsEqn.solve();
+    }
+
+    thermo.correct();
+    combustion->correct();
+}

applications/solvers/combustion/fireFoam/pEqn.H

@@ -0,0 +1,64 @@
+bool closedVolume = false;
+
+rho = thermo.rho();
+
+volScalarField rUA = 1.0/UEqn.A();
+surfaceScalarField rhorUAf("(rho*(1|A(U)))", fvc::interpolate(rho*rUA));
+U = rUA*UEqn.H();
+
+surfaceScalarField phiU
+(
+    fvc::interpolate(rho)
+   *(
+        (fvc::interpolate(U) & mesh.Sf())
+      + fvc::ddtPhiCorr(rUA, rho, U, phi)
+    )
+);
+
+phi = phiU + rhorUAf*fvc::interpolate(rho)*(g & mesh.Sf());
+
+for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+{
+       surfaceScalarField rhorUAf = fvc::interpolate(rho*rUA);
+
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi,p)
+          + fvc::div(phi)
+          - fvm::laplacian(rhorUAf, p)
+        );
+
+        closedVolume = p.needReference();
+
+        if (corr == nCorr-1 && nonOrth == nNonOrthCorr)
+        {
+            pEqn.solve(mesh.solver(p.name() + "Final"));
+        }
+        else
+        {
+            pEqn.solve(mesh.solver(p.name()));
+        }
+
+        if (nonOrth == nNonOrthCorr)
+        {
+            phi += pEqn.flux();
+        }
+}
+
+DpDt = fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);
+
+#include "rhoEqn.H"
+#include "compressibleContinuityErrs.H"
+
+U += rUA*fvc::reconstruct((phi - phiU)/rhorUAf);
+U.correctBoundaryConditions();
+
+// For closed-volume cases adjust the pressure and density levels
+// to obey overall mass continuity
+if (closedVolume)
+{
+    p +=
+        (initialMass - fvc::domainIntegrate(thermo.psi()*p))
+       /fvc::domainIntegrate(thermo.psi());
+    rho = thermo.rho();
+}

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/Allwmake

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wmake libso basic
+wmake libso reactionThermo
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/Make/files

@@ -0,0 +1,4 @@
+psiThermo/basicSensiblePsiThermo/basicSensiblePsiThermo.C
+psiThermo/basicSensiblePsiThermo/newBasicSensiblePsiThermo.C
+
+LIB = $(FOAM_LIBBIN)/libbasicSensibleEnthalpyThermophysicalModels

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/Make/options

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/psiThermo/basicSensiblePsiThermo/basicSensiblePsiThermo.C

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "basicSensiblePsiThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(basicSensiblePsiThermo, 0);
+    defineRunTimeSelectionTable(basicSensiblePsiThermo, fvMesh);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::basicSensiblePsiThermo::basicSensiblePsiThermo(const fvMesh& mesh)
+:
+    basicThermo(mesh)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::basicSensiblePsiThermo::~basicSensiblePsiThermo()
+{}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/psiThermo/basicSensiblePsiThermo/basicSensiblePsiThermo.H

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::basicSensiblePsiThermo
+
+Description
+    Basic thermodynamic properties based on compressibility
+
+SourceFiles
+    basicSensiblePsiThermo.C
+    newBasicSensiblePsiThermo.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef basicSensiblePsiThermo_H
+#define basicSensiblePsiThermo_H
+
+#include "basicThermo.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class basicSensiblePsiThermo Declaration
+\*---------------------------------------------------------------------------*/
+
+class basicSensiblePsiThermo
+:
+    public basicThermo
+{
+
+protected:
+
+    // Protected member functions
+
+        //- Construct as copy (not implemented)
+        basicSensiblePsiThermo(const basicSensiblePsiThermo&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("basicSensiblePsiThermo");
+
+
+    //- Declare run-time constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        basicSensiblePsiThermo,
+        fvMesh,
+        (const fvMesh& mesh),
+        (mesh)
+    );
+
+    // Constructors
+
+        //- Construct from mesh
+        basicSensiblePsiThermo(const fvMesh&);
+
+
+    //- Selector
+    static autoPtr<basicSensiblePsiThermo> New(const fvMesh&);
+
+    //- Destructor
+    virtual ~basicSensiblePsiThermo();
+
+
+    // Member functions
+
+        // Fields derived from thermodynamic state variables
+
+            //- Density [kg/m^3] - uses current value of pressure
+            virtual tmp<volScalarField> rho() const
+            {
+                return p_*psi();
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/psiThermo/basicSensiblePsiThermo/makeBasicSensiblePsiThermo.H

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+InClass
+    Foam::basicSensiblePsiThermo
+
+Description
+    Macros for creating 'basic' compresibility-based thermo packages
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeBasicSensiblePsiThermo_H
+#define makeBasicSensiblePsiThermo_H
+
+#include "basicSensiblePsiThermo.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeBasicSensiblePsiThermo(Cthermo,Mixture,Transport,Thermo,EqnOfState)       \
+                                                                              \
+typedef Cthermo<Mixture<Transport<specieThermo<Thermo<EqnOfState> > > > >     \
+    Cthermo##Mixture##Transport##Thermo##EqnOfState;                          \
+                                                                              \
+defineTemplateTypeNameAndDebugWithName                                        \
+(                                                                             \
+    Cthermo##Mixture##Transport##Thermo##EqnOfState,                          \
+    #Cthermo                                                                  \
+        "<"#Mixture"<"#Transport"<specieThermo<"#Thermo"<"#EqnOfState">>>>>", \
+    0                                                                         \
+);                                                                            \
+                                                                              \
+addToRunTimeSelectionTable                                                    \
+(                                                                             \
+    basicSensiblePsiThermo,                                                           \
+    Cthermo##Mixture##Transport##Thermo##EqnOfState,                          \
+    fvMesh                                                                    \
+)
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/basic/psiThermo/basicSensiblePsiThermo/newBasicSensiblePsiThermo.C

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "basicSensiblePsiThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::basicSensiblePsiThermo> Foam::basicSensiblePsiThermo::New
+(
+    const fvMesh& mesh
+)
+{
+    word thermoTypeName;
+
+    // Enclose the creation of the thermophysicalProperties to ensure it is
+    // deleted before the turbulenceModel is created otherwise the dictionary
+    // is entered in the database twice
+    {
+        IOdictionary thermoDict
+        (
+            IOobject
+            (
+                "thermophysicalProperties",
+                mesh.time().constant(),
+                mesh,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        thermoDict.lookup("thermoType") >> thermoTypeName;
+    }
+
+    Info<< "Selecting thermodynamics package " << thermoTypeName << endl;
+
+    fvMeshConstructorTable::iterator cstrIter =
+        fvMeshConstructorTablePtr_->find(thermoTypeName);
+
+    if (cstrIter == fvMeshConstructorTablePtr_->end())
+    {
+        FatalErrorIn("basicSensiblePsiThermo::New(const fvMesh&)")
+            << "Unknown basicSensiblePsiThermo type " << thermoTypeName << nl << nl
+            << "Valid basicSensiblePsiThermo types are:" << nl
+            << fvMeshConstructorTablePtr_->toc() << nl
+            << exit(FatalError);
+    }
+
+    return autoPtr<basicSensiblePsiThermo>(cstrIter()(mesh));
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/Make/files

@@ -0,0 +1,5 @@
+combustionThermo/hsCombustionThermo/hsCombustionThermo.C
+combustionThermo/hsCombustionThermo/newhsCombustionThermo.C
+combustionThermo/hsCombustionThermo/hsCombustionThermos.C
+
+LIB = $(FOAM_LIBBIN)/libreactionSensibleEnthalpyThermophysicalModels

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I../basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/hsCombustionThermo/hsCombustionThermo.C

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "hsCombustionThermo.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(hsCombustionThermo, 0);
+    defineRunTimeSelectionTable(hsCombustionThermo, fvMesh);
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::hsCombustionThermo::hsCombustionThermo(const fvMesh& mesh)
+:
+    basicSensiblePsiThermo(mesh),
+
+    hs_
+    (
+        IOobject
+        (
+            "hs",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionSet(0, 2, -2, 0, 0),
+        this->hBoundaryTypes()
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::hsCombustionThermo::~hsCombustionThermo()
+{}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/hsCombustionThermo/hsCombustionThermo.H

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::hsCombustionThermo
+
+Description
+    Foam::hsCombustionThermo
+
+SourceFiles
+    hsCombustionThermo.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hsCombustionThermo_H
+#define hsCombustionThermo_H
+
+#include "basicSensiblePsiThermo.H"
+#include "basicMultiComponentMixture.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class hsCombustionThermo Declaration
+\*---------------------------------------------------------------------------*/
+
+class hsCombustionThermo
+:
+    public basicSensiblePsiThermo
+{
+
+protected:
+
+    // Protected data
+
+        //- sensible enthalpy field
+        volScalarField hs_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hsCombustionThermo");
+
+
+    //- Declare run-time constructor selection tables
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        hsCombustionThermo,
+        fvMesh,
+        (const fvMesh& mesh),
+        (mesh)
+    );
+
+
+    // Constructors
+
+        //- Construct from dictionary and mesh
+        hsCombustionThermo(const fvMesh&);
+
+
+    // Selectors
+
+        //- Standard selection based on fvMesh
+        static autoPtr<hsCombustionThermo> New(const fvMesh&);
+
+        //- Select and check that package contains 'thermoType'
+        static autoPtr<hsCombustionThermo> NewType
+        (
+            const fvMesh&,
+            const word& thermoType
+        );
+
+
+    //- Destructor
+    virtual ~hsCombustionThermo();
+
+
+    // Member functions
+
+        //- Return the composition of the multi-component mixture
+        virtual basicMultiComponentMixture& composition() = 0;
+
+        //- Return the composition of the multi-component mixture
+        virtual const basicMultiComponentMixture& composition() const = 0;
+
+
+        // Access to thermodynamic state variables
+
+            //- Sensible enthalpy [J/kg]
+            //  Non-const access allowed for transport equations
+            virtual volScalarField& hs()
+            {
+                return hs_;
+            }
+
+            //- Sensible enthalpy [J/kg]
+            virtual const volScalarField& hs() const
+            {
+                return hs_;
+            }
+
+        //- Chemical enthalpy [J/kg]
+        virtual tmp<volScalarField> hc() const = 0;
+
+        //- Update properties
+        virtual void correct() = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/hsCombustionThermo/hsCombustionThermos.C

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "makeHsCombustionThermo.H"
+
+#include "hsCombustionThermo.H"
+#include "hsPsiMixtureThermo.H"
+
+#include "perfectGas.H"
+
+#include "hConstThermo.H"
+#include "janafThermo.H"
+#include "specieThermo.H"
+
+#include "sutherlandTransport.H"
+
+#include "veryInhomogeneousMixture.H"
+
+#include "multiComponentMixture.H"
+
+#include "thermoPhysicsTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+makeHsCombustionThermo
+(
+    hsCombustionThermo,
+    hsPsiMixtureThermo,
+    veryInhomogeneousMixture,
+    sutherlandTransport,
+    janafThermo,
+    perfectGas
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/hsCombustionThermo/makeHsCombustionThermo.H

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+InClass
+    Foam::hsCombustionThermo
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeHsCombustionThermo_H
+#define makeHsCombustionThermo_H
+
+#include "addToRunTimeSelectionTable.H"
+#include "basicSensiblePsiThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeHsCombustionThermo(CThermo,MixtureThermo,Mixture,Transport,Thermo,EqnOfState) \
+                                                                              \
+typedef MixtureThermo                                                         \
+    <Mixture<Transport<specieThermo<Thermo<EqnOfState> > > > >                \
+    MixtureThermo##Mixture##Transport##Thermo##EqnOfState;                    \
+                                                                              \
+defineTemplateTypeNameAndDebugWithName                                        \
+(                                                                             \
+    MixtureThermo##Mixture##Transport##Thermo##EqnOfState,                    \
+    #MixtureThermo                                                            \
+        "<"#Mixture"<"#Transport"<specieThermo<"#Thermo"<"#EqnOfState">>>>>", \
+    0                                                                         \
+);                                                                            \
+                                                                              \
+addToRunTimeSelectionTable                                                    \
+(                                                                             \
+    basicSensiblePsiThermo,                                                   \
+    MixtureThermo##Mixture##Transport##Thermo##EqnOfState,                    \
+    fvMesh                                                                    \
+);                                                                            \
+                                                                              \
+addToRunTimeSelectionTable                                                    \
+(                                                                             \
+    CThermo,                                                                  \
+    MixtureThermo##Mixture##Transport##Thermo##EqnOfState,                    \
+    fvMesh                                                                    \
+)
+
+
+#define makeHsCombustionMixtureThermo(CThermo,MixtureThermo,Mixture,ThermoPhys) \
+                                                                              \
+typedef MixtureThermo<Mixture<ThermoPhys> >                                   \
+    MixtureThermo##Mixture##ThermoPhys;                                       \
+                                                                              \
+defineTemplateTypeNameAndDebugWithName                                        \
+(                                                                             \
+    MixtureThermo##Mixture##ThermoPhys,                                       \
+    #MixtureThermo"<"#Mixture"<"#ThermoPhys">>",                              \
+    0                                                                         \
+);                                                                            \
+                                                                              \
+addToRunTimeSelectionTable                                                    \
+(                                                                             \
+    basicSensiblePsiThermo,                                                   \
+    MixtureThermo##Mixture##ThermoPhys,                                       \
+    fvMesh                                                                    \
+);                                                                            \
+                                                                              \
+addToRunTimeSelectionTable                                                    \
+(                                                                             \
+    CThermo,                                                                  \
+    MixtureThermo##Mixture##ThermoPhys,                                       \
+    fvMesh                                                                    \
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/hsCombustionThermo/newhsCombustionThermo.C

@@ -0,0 +1,151 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "hsCombustionThermo.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::hsCombustionThermo> Foam::hsCombustionThermo::New
+(
+    const fvMesh& mesh
+)
+{
+    word hsCombustionThermoTypeName;
+
+    // Enclose the creation of the thermophysicalProperties to ensure it is
+    // deleted before the turbulenceModel is created otherwise the dictionary
+    // is entered in the database twice
+    {
+        IOdictionary thermoDict
+        (
+            IOobject
+            (
+                "thermophysicalProperties",
+                mesh.time().constant(),
+                mesh,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        thermoDict.lookup("thermoType") >> hsCombustionThermoTypeName;
+    }
+
+    Info<< "Selecting thermodynamics package " << hsCombustionThermoTypeName
+        << endl;
+
+    fvMeshConstructorTable::iterator cstrIter =
+        fvMeshConstructorTablePtr_->find(hsCombustionThermoTypeName);
+
+    if (cstrIter == fvMeshConstructorTablePtr_->end())
+    {
+        FatalErrorIn("hsCombustionThermo::New(const fvMesh&)")
+            << "Unknown hsCombustionThermo type "
+            << hsCombustionThermoTypeName << nl << nl
+            << "Valid hsCombustionThermo types are:" << nl
+            << fvMeshConstructorTablePtr_->toc() << nl
+            << exit(FatalError);
+    }
+
+    return autoPtr<hsCombustionThermo>(cstrIter()(mesh));
+}
+
+
+Foam::autoPtr<Foam::hsCombustionThermo> Foam::hsCombustionThermo::NewType
+(
+    const fvMesh& mesh,
+    const word& thermoType
+)
+{
+    word hsCombustionThermoTypeName;
+
+    // Enclose the creation of the thermophysicalProperties to ensure it is
+    // deleted before the turbulenceModel is created otherwise the dictionary
+    // is entered in the database twice
+    {
+        IOdictionary thermoDict
+        (
+            IOobject
+            (
+                "thermophysicalProperties",
+                mesh.time().constant(),
+                mesh,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        thermoDict.lookup("thermoType") >> hsCombustionThermoTypeName;
+
+        if (hsCombustionThermoTypeName.find(thermoType) == string::npos)
+        {
+            wordList allModels = fvMeshConstructorTablePtr_->toc();
+            DynamicList<word> validModels;
+            forAll(allModels, i)
+            {
+                if (allModels[i].find(thermoType) != string::npos)
+                {
+                    validModels.append(allModels[i]);
+                }
+            }
+
+            FatalErrorIn
+            (
+                "autoPtr<hsCombustionThermo> hsCombustionThermo::NewType"
+                "("
+                    "const fvMesh&, "
+                    "const word&"
+                ")"
+            )   << "Inconsistent thermo package selected:" << nl << nl
+                << hsCombustionThermoTypeName << nl << nl << "Please select a "
+                << "thermo package based on " << thermoType
+                << ". Valid options include:" << nl << validModels << nl
+                << exit(FatalError);
+        }
+    }
+
+    Info<< "Selecting thermodynamics package " << hsCombustionThermoTypeName
+        << endl;
+
+    fvMeshConstructorTable::iterator cstrIter =
+        fvMeshConstructorTablePtr_->find(hsCombustionThermoTypeName);
+
+    if (cstrIter == fvMeshConstructorTablePtr_->end())
+    {
+        FatalErrorIn("hsCombustionThermo::New(const fvMesh&)")
+            << "Unknown hsCombustionThermo type "
+            << hsCombustionThermoTypeName << nl << nl
+            << "Valid hsCombustionThermo types are:" << nl
+            << fvMeshConstructorTablePtr_->toc() << nl
+            << exit(FatalError);
+    }
+
+    return autoPtr<hsCombustionThermo>(cstrIter()(mesh));
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/mixtureThermos/hsPsiMixtureThermo/hsPsiMixtureThermo.C

@@ -0,0 +1,318 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "hsPsiMixtureThermo.H"
+#include "fvMesh.H"
+#include "fixedValueFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class MixtureType>
+Foam::hsPsiMixtureThermo<MixtureType>::hsPsiMixtureThermo(const fvMesh& mesh)
+:
+    hsCombustionThermo(mesh),
+    MixtureType(*this, mesh)
+{
+    scalarField& hCells = hs_.internalField();
+    const scalarField& TCells = T_.internalField();
+
+    forAll(hCells, celli)
+    {
+        hCells[celli] = this->cellMixture(celli).Hs(TCells[celli]);
+    }
+
+    forAll(hs_.boundaryField(), patchi)
+    {
+        hs_.boundaryField()[patchi] == hs(T_.boundaryField()[patchi], patchi);
+    }
+
+    hBoundaryCorrection(hs_);
+
+    calculate();
+    psi_.oldTime();   // Switch on saving old time
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class MixtureType>
+Foam::hsPsiMixtureThermo<MixtureType>::~hsPsiMixtureThermo()
+{}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class MixtureType>
+void Foam::hsPsiMixtureThermo<MixtureType>::calculate()
+{
+    const scalarField& hsCells = hs_.internalField();
+    const scalarField& pCells = p_.internalField();
+
+    scalarField& TCells = T_.internalField();
+    scalarField& psiCells = psi_.internalField();
+    scalarField& muCells = mu_.internalField();
+    scalarField& alphaCells = alpha_.internalField();
+
+    forAll(TCells, celli)
+    {
+        const typename MixtureType::thermoType& mixture_ =
+            this->cellMixture(celli);
+
+        TCells[celli] = mixture_.THs(hsCells[celli], TCells[celli]);
+        psiCells[celli] = mixture_.psi(pCells[celli], TCells[celli]);
+
+        muCells[celli] = mixture_.mu(TCells[celli]);
+        alphaCells[celli] = mixture_.alpha(TCells[celli]);
+    }
+
+    forAll(T_.boundaryField(), patchi)
+    {
+        fvPatchScalarField& pp = p_.boundaryField()[patchi];
+        fvPatchScalarField& pT = T_.boundaryField()[patchi];
+        fvPatchScalarField& ppsi = psi_.boundaryField()[patchi];
+
+        fvPatchScalarField& phs = hs_.boundaryField()[patchi];
+
+        fvPatchScalarField& pmu_ = mu_.boundaryField()[patchi];
+        fvPatchScalarField& palpha_ = alpha_.boundaryField()[patchi];
+
+        if (pT.fixesValue())
+        {
+            forAll(pT, facei)
+            {
+                const typename MixtureType::thermoType& mixture_ =
+                    this->patchFaceMixture(patchi, facei);
+
+                phs[facei] = mixture_.Hs(pT[facei]);
+
+                ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
+                pmu_[facei] = mixture_.mu(pT[facei]);
+                palpha_[facei] = mixture_.alpha(pT[facei]);
+            }
+        }
+        else
+        {
+            forAll(pT, facei)
+            {
+                const typename MixtureType::thermoType& mixture_ =
+                    this->patchFaceMixture(patchi, facei);
+
+                pT[facei] = mixture_.THs(phs[facei], pT[facei]);
+
+                ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
+                pmu_[facei] = mixture_.mu(pT[facei]);
+                palpha_[facei] = mixture_.alpha(pT[facei]);
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class MixtureType>
+void Foam::hsPsiMixtureThermo<MixtureType>::correct()
+{
+    if (debug)
+    {
+        Info<< "entering hMixtureThermo<MixtureType>::correct()" << endl;
+    }
+
+    // force the saving of the old-time values
+    psi_.oldTime();
+
+    calculate();
+
+    if (debug)
+    {
+        Info<< "exiting hMixtureThermo<MixtureType>::correct()" << endl;
+    }
+}
+
+template<class MixtureType>
+Foam::tmp<Foam::volScalarField>
+Foam::hsPsiMixtureThermo<MixtureType>::hc() const
+{
+    const fvMesh& mesh = T_.mesh();
+
+    tmp<volScalarField> thc
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "hc",
+                mesh.time().timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh,
+            hs_.dimensions()
+        )
+    );
+
+    volScalarField& hcf = thc();
+    scalarField& hcCells = hcf.internalField();
+
+    forAll(hcCells, celli)
+    {
+        hcCells[celli] = this->cellMixture(celli).Hc();
+    }
+
+    forAll(hcf.boundaryField(), patchi)
+    {
+        scalarField& hcp = hcf.boundaryField()[patchi];
+
+        forAll(hcp, facei)
+        {
+            hcp[facei] = this->patchFaceMixture(patchi, facei).Hc();
+        }
+    }
+
+    return thc;
+}
+
+
+template<class MixtureType>
+Foam::tmp<Foam::scalarField>
+Foam::hsPsiMixtureThermo<MixtureType>::hs
+(
+    const scalarField& T,
+    const labelList& cells
+) const
+{
+    tmp<scalarField> th(new scalarField(T.size()));
+    scalarField& hs = th();
+
+    forAll(T, celli)
+    {
+        hs[celli] = this->cellMixture(cells[celli]).Hs(T[celli]);
+    }
+
+    return th;
+}
+
+
+template<class MixtureType>
+Foam::tmp<Foam::scalarField>
+Foam::hsPsiMixtureThermo<MixtureType>::hs
+(
+    const scalarField& T,
+    const label patchi
+) const
+{
+    tmp<scalarField> th(new scalarField(T.size()));
+    scalarField& hs = th();
+
+    forAll(T, facei)
+    {
+        hs[facei] = this->patchFaceMixture(patchi, facei).Hs(T[facei]);
+    }
+
+    return th;
+}
+
+
+template<class MixtureType>
+Foam::tmp<Foam::scalarField>
+Foam::hsPsiMixtureThermo<MixtureType>::Cp
+(
+    const scalarField& T,
+    const label patchi
+) const
+{
+    tmp<scalarField> tCp(new scalarField(T.size()));
+
+    scalarField& cp = tCp();
+
+    forAll(T, facei)
+    {
+        cp[facei] = this->patchFaceMixture(patchi, facei).Cp(T[facei]);
+    }
+
+    return tCp;
+}
+
+
+template<class MixtureType>
+Foam::tmp<Foam::volScalarField>
+Foam::hsPsiMixtureThermo<MixtureType>::Cp() const
+{
+    const fvMesh& mesh = T_.mesh();
+
+    tmp<volScalarField> tCp
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "Cp",
+                mesh.time().timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh,
+            dimensionSet(0, 2, -2, -1, 0)
+        )
+    );
+
+    volScalarField& cp = tCp();
+
+    scalarField& cpCells = cp.internalField();
+    const scalarField& TCells = T_.internalField();
+
+    forAll(TCells, celli)
+    {
+        cpCells[celli] = this->cellMixture(celli).Cp(TCells[celli]);
+    }
+
+    forAll(T_.boundaryField(), patchi)
+    {
+        cp.boundaryField()[patchi] = Cp(T_.boundaryField()[patchi], patchi);
+    }
+
+    return tCp;
+}
+
+
+template<class MixtureType>
+bool Foam::hsPsiMixtureThermo<MixtureType>::read()
+{
+    if (hsCombustionThermo::read())
+    {
+        MixtureType::read(*this);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/fireFoam/sensibleEnthalpyCombustionThermophysicalModels/reactionThermo/combustionThermo/mixtureThermos/hsPsiMixtureThermo/hsPsiMixtureThermo.H

@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::hsPsiMixtureThermo
+
+Description
+    Foam::hsPsiMixtureThermo
+
+SourceFiles
+    hsPsiMixtureThermo.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef hsPsiMixtureThermo_H
+#define hsPsiMixtureThermo_H
+
+#include "hsCombustionThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class hsPsiMixtureThermo Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class MixtureType>
+class hsPsiMixtureThermo
+:
+    public hsCombustionThermo,
+    public MixtureType
+{
+    // Private member functions
+
+        void calculate();
+
+        //- Construct as copy (not implemented)
+        hsPsiMixtureThermo(const hsPsiMixtureThermo<MixtureType>&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("hsPsiMixtureThermo");
+
+
+    // Constructors
+
+        //- Construct from mesh
+        hsPsiMixtureThermo(const fvMesh&);
+
+
+    //- Destructor
+    virtual ~hsPsiMixtureThermo();
+
+
+    // Member functions
+
+        //- Return the compostion of the multi-component mixture
+        virtual basicMultiComponentMixture& composition()
+        {
+            return *this;
+        }
+
+        //- Return the compostion of the multi-component mixture
+        virtual const basicMultiComponentMixture& composition() const
+        {
+            return *this;
+        }
+
+        //- Update properties
+        virtual void correct();
+
+
+        //- Chemical enthalpy [J/kg]
+        virtual tmp<volScalarField> hc() const;
+
+        // Fields derived from thermodynamic state variables
+
+            //- Sensible enthalpy for cell-set [J/kg]
+            virtual tmp<scalarField> hs
+            (
+                const scalarField& T,
+                const labelList& cells
+            ) const;
+
+            //- Sensible enthalpy for patch [J/kg]
+            virtual tmp<scalarField> hs
+            (
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Heat capacity at constant pressure for patch [J/kg/K]
+            virtual tmp<scalarField> Cp
+            (
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Heat capacity at constant pressure [J/kg/K]
+            virtual tmp<volScalarField> Cp() const;
+
+
+        //- Read thermophysicalProperties dictionary
+        virtual bool read();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "hsPsiMixtureThermo.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/lagrangian/coalChemistryFoam/coalChemistryFoam.C

@@ -26,8 +26,13 @@ Application
     coalChemistryFoam
 
 Description
-    Transient solver for compressible, turbulent flow with coal and
-    limestone parcel injections, and combustion.
+    Transient solver for:
+    - compressible,
+    - turbulent flow,
+    with
+    - coal and limestone parcel injections,
+    - energy source, and
+    - combustion.
 
 \*---------------------------------------------------------------------------*/
 
@@ -38,7 +43,7 @@ Description
 #include "CoalCloud.H"
 #include "psiChemistryModel.H"
 #include "chemistrySolver.H"
-#include "timeActivatedExplicitCellSource.H"
+#include "timeActivatedExplicitSource.H"
 #include "radiationModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/solvers/lagrangian/coalChemistryFoam/createFields.H

@@ -127,10 +127,11 @@
         fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p)
     );
 
-    Info<< "\nConstructing explicit enthalpy cell source" << endl;
-    timeActivatedExplicitCellSource enthalpySource
+    Info<< "\nConstructing explicit enthalpy source" << endl;
+    scalarTimeActivatedExplicitSourceList enthalpySource
     (
-        "enthalpySource",
+        "energy",
         mesh,
-        h.dimensions()*phi.dimensions()/mesh.V().dimensions()
+        dimEnergy/dimTime/dimVolume,
+        "h"
     );

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/UEqn.H

@@ -7,6 +7,7 @@
      ==
         rho.dimensionedInternalField()*g
       + parcels.SU()
+      + momentumSource.Su()
     );
 
     pZones.addResistance(UEqn);

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/YEqn.H

@@ -28,7 +28,7 @@ tmp<fv::convectionScheme<scalar> > mvConvection
               ==
                 parcels.Srho(i)
               + kappa*chemistry.RR(i)().dimensionedInternalField()
-              + pointMassSources.Su(i),
+              + massSource.Su(i),
                 mesh.solver("Yi")
             );
 

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createClouds.H

@@ -1,5 +1,5 @@
 Info<< "\nConstructing reacting cloud" << endl;
-icoPoly8ThermoReactingCloud parcels
+icoPoly8ThermoReactingMultiphaseCloud parcels
 (
     "reactingCloud1",
     rho,

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createExplicitSources.H

@@ -0,0 +1,27 @@
+Info<< "Creating mass source\n" << endl;
+scalarTimeActivatedExplicitSourceList massSource
+(
+    "mass",
+    mesh,
+    dimMass/dimTime/dimVolume,
+    composition.species()
+);
+
+
+Info<< "Creating momentum source\n" << endl;
+vectorTimeActivatedExplicitSourceList momentumSource
+(
+    "momentum",
+    mesh,
+    dimMass*dimVelocity/dimTime/dimVolume,
+    "U"
+);
+
+Info<< "Creating energy source\n" << endl;
+scalarTimeActivatedExplicitSourceList energySource
+(
+    "energy",
+    mesh,
+    dimEnergy/dimTime/dimVolume,
+    "h"
+);

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createMulticomponentPointSources.H

@@ -1,8 +0,0 @@
-Info<< "\nConstructing multi-component mass flow rate point sources" << endl;
-timeActivatedExplicitMulticomponentPointSource pointMassSources
-(
-    "pointMassSources",
-    mesh,
-    Y,
-    dimMass/dimVolume/dimTime
-);

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/hEqn.H

@@ -39,6 +39,7 @@
             pWork()
           + parcels.Sh()
           + radiation->Sh(thermo)
+          + energySource.Su()
         );
 
         thermo.correct();

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/pEqn.H

@@ -32,7 +32,7 @@
           - fvm::laplacian(rho*rAU, p)
         ==
             parcels.Srho()
-          + pointMassSources.Su()
+          + massSource.SuTot()
         );
 
         if (corr == nCorr-1 && nonOrth == nNonOrthCorr)

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/porousExplicitSourceReactingParcelFoam.C

@@ -27,10 +27,11 @@ Application
 
 Description
     Transient PISO solver for compressible, laminar or turbulent flow with
-    reacting Lagrangian parcels for porous media, including explicit sources
+    reacting multiphase Lagrangian parcels for porous media, including explicit
+    sources for mass, momentum and energy
 
     The solver includes:
-    - reacting parcel cloud
+    - reacting multiphase parcel cloud
     - porous media
     - point mass sources
     - polynomial based, incompressible thermodynamics (f(T))
@@ -43,12 +44,12 @@ Description
 #include "fvCFD.H"
 #include "hReactionThermo.H"
 #include "turbulenceModel.H"
-#include "BasicReactingCloud.H"
+#include "BasicReactingMultiphaseCloud.H"
 #include "rhoChemistryModel.H"
 #include "chemistrySolver.H"
 #include "radiationModel.H"
 #include "porousZones.H"
-#include "timeActivatedExplicitMulticomponentPointSource.H"
+#include "timeActivatedExplicitSource.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -63,7 +64,7 @@ int main(int argc, char *argv[])
     #include "createFields.H"
     #include "createRadiationModel.H"
     #include "createClouds.H"
-    #include "createMulticomponentPointSources.H"
+    #include "createExplicitSources.H"
     #include "createPorousZones.H"
     #include "initContinuityErrs.H"
     #include "readTimeControls.H"

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/rhoEqn.H

@@ -37,7 +37,7 @@ Description
       + fvc::div(phi)
       ==
         parcels.Srho()
-      + pointMassSources.Su()
+      + massSource.SuTot()
     );
 
     rhoEqn.relax();

applications/test/dictionary/Allwmake

@@ -1,15 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # run from this directory
-
-# this will have to do until we have a makefile rule
-
-if type Coco > /dev/null 2>&1
-then
-    Coco \
-        -frames $WM_THIRD_PARTY_DIR/coco-r \
-        calcEntry/calcEntry.atg
-else
-    echo "Coco not installed"
-fi
-
-wmake

applications/test/dictionary/Make/files

@@ -1,7 +1,3 @@
 dictionaryTest.C
 
-calcEntry/calcEntry.C
-calcEntry/calcEntryParser.cpp
-calcEntry/calcEntryScanner.cpp
-
 EXE = $(FOAM_USER_APPBIN)/dictionaryTest

applications/test/dictionary/Make/options

@@ -0,0 +1 @@
+EXE_INC =

applications/test/dictionary/calcEntry/calcEntry.C

@@ -1,92 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
-     \\/     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 2 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, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-\*---------------------------------------------------------------------------*/
-
-#include "calcEntry.H"
-#include "dictionary.H"
-#include "addToMemberFunctionSelectionTable.H"
-
-#include "ISstream.H"
-#include "CocoParserErrors.H"
-#include "calcEntryParser.h"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-namespace functionEntries
-{
-    defineTypeNameAndDebug(calcEntry, 0);
-
-    addToMemberFunctionSelectionTable
-    (
-        functionEntry,
-        calcEntry,
-        execute,
-        primitiveEntryIstream
-    );
-
-}
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::functionEntries::calcEntry::execute
-(
-    const dictionary& parentDict,
-    primitiveEntry& entry,
-    Istream& is
-)
-{
-    std::istream& iss = dynamicCast<ISstream>(is).stdStream();
-
-    // define parser error handler
-    CocoParserErrors<calcEntryInternal::Errors>
-        myErrorHandler("calcEntryInternal::Parser");
-
-    calcEntryInternal::Scanner scanner(iss);
-    calcEntryInternal::Parser  parser(&scanner, &myErrorHandler);
-
-    // Attach dictionary context
-    parser.dict(parentDict);
-
-    // Attach scalar functions
-    // parser.functions(parentDict);
-
-    parser.Parse();
-
-    // make a small input list to contain the answer
-    tokenList tokens(2);
-    tokens[0] = parser.Result();
-    tokens[1] = token::END_STATEMENT;
-
-    entry.read(parentDict, ITstream("ParserResult", tokens)());
-
-    return true;
-}
-
-
-// ************************************************************************* //

applications/test/dictionary/calcEntry/calcEntry.atg

@@ -1,252 +0,0 @@
-/*-------------------------------------------------------------------------
- compile with:
- Coco \
-    -frames $WM_THIRD_PARTY_DIR/coco-r \
-    calcEntry.atg
--------------------------------------------------------------------------*/
-
-#include "dictionary.H"
-#include "scalar.H"
-#include "error.H"
-#include "wchar.H"
-
-
-COMPILER calcEntry
-$prefix=calcEntry
-$namespace=Foam::functionEntries::calcEntryInternal
-$eof=true     // grammar handles eof itself
-
-    // Simple four function calculator for OpenFOAM dictionaries
-
-    //! with debug
-    static const int debug = 0;
-
-    //! The parent dictionary
-    mutable dictionary* dict_;
-
-    //! Track that parent dictionary was set
-    bool hasDict_;
-
-    //! The calculation result
-    scalar val;
-
-
-    //! token -> scalar
-    scalar getScalar() const
-    {
-        return coco_string_toDouble(t->val);
-    }
-
-    //! token -> string
-    std::string getString() const
-    {
-        char* str = coco_string_create_char(t->val);
-        std::string s(str);
-        coco_string_delete(str);
-        return s;
-    }
-
-    //! attach a dictionary
-    void dict(const dictionary& dict)
-    {
-        dict_ = const_cast<dictionary*>(&dict);
-        hasDict_ = true;
-    }
-
-
-    //! lookup dictionary entry
-    scalar getDictLookup() const
-    {
-        scalar dictValue = 0;
-
-        if (!hasDict_)
-        {
-            FatalErrorIn
-            (
-                "calcEntry::getDictEntry() const"
-            )   << "No dictionary attached!"
-                << exit(FatalError);
-
-            return 0;
-        }
-
-        char* chars = coco_string_create_char
-        (
-            t->val,
-            1,
-            (coco_string_length(t->val) - 1)
-        );
-        word keyword(chars);
-        coco_string_delete(chars);
-
-        if (debug)
-        {
-            Info<<"lookup: " << keyword << nl;
-        }
-
-        entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
-        if (entryPtr && !entryPtr->isDict())
-        {
-            if (entryPtr->stream().size() != 1)
-            {
-                FatalErrorIn
-                (
-                    "calcEntry::getDictEntry() const"
-                )   << "keyword " << keyword << " has "
-                    << entryPtr->stream().size() << " values in dictionary "
-                    << exit(FatalError);
-            }
-            entryPtr->stream() >> dictValue;
-        }
-        else
-        {
-            FatalErrorIn
-            (
-                "calcEntry::getDictEntry() const"
-            )   << "keyword " << keyword << " is undefined in dictionary "
-                << exit(FatalError);
-        }
-
-
-        return dictValue;
-    }
-
-    scalar Result() const
-    {
-        return val;
-    }
-
-
-/*---------------------------------------------------------------------------*/
-
-CHARACTERS
-    letter    = 'A'..'Z' + 'a'..'z'.
-    qualifier = '_' + ':'.
-    dollar    = '$'.
-    digit     = "0123456789".
-    sign      = '+' + '-'.
-    cr        = '\r'.
-    lf        = '\n'.
-    tab       = '\t'.
-    stringCh  = ANY - '"' - '\\' - cr - lf.
-    printable = '\u0020' .. '\u007e'.
-
-
-// * * * * * * * * * * * * * * * *  TOKENS * * * * * * * * * * * * * * * * * //
-
-TOKENS
-
-// identifier
-ident  =
-    letter { letter | digit | qualifier }.
-
-// string
-string =
-    '"' { stringCh | '\\' printable } '"'.
-
-// dictionary lookup identifier
-// starts with '$' and otherwise limited to a normal indentifier
-variable  =
-    dollar letter { letter | digit | qualifier }.
-
-// floating point and integer numbers
-number  =
-    [sign] ('.' digit { digit } ) | ( digit { digit } [ '.' { digit } ])
-    [ ('E' | 'e') [sign] digit { digit } ].
-
-
-// * * * * * * * * * * *  PRAGMAS / COMMENTS / IGNORE  * * * * * * * * * * * //
-
-COMMENTS FROM "/*" TO "*/" NESTED
-COMMENTS FROM "//" TO lf
-
-IGNORE cr + lf + tab
-
-
-// * * * * * * * * * * * * * * *  PRODUCTIONS  * * * * * * * * * * * * * * * //
-
-PRODUCTIONS
-
-calcEntry                       (. val = 0;
-                                 if (debug){Info<<"start val pos:"<< t->pos << nl;}
-                                 .)
-=
-  '{' Expr<val> '}'             (.
-                                   if (debug){
-                                       Info<<"end {} at pos:"<< t->pos
-                                           <<" val:"<< t->val
-                                           <<" len:"<< coco_string_length(t->val)
-                                           <<" la pos:"<< la->pos << nl;
-                                   }
-                                   // reposition to immediately after the closing '}'
-                                   scanner->buffer->SetPos
-                                   (
-                                       t->pos + coco_string_length(t->val)
-                                   );
-                                 .)
-    | ( Expr<val> EOF )
-.
-
-
-/*---------------------------------------------------------------------------*/
-
-Expr<scalar& val>               (. scalar val2 = 0;
-                                   if (debug) {Info<<"Expr:"<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-=
-  Term<val>
-  {
-      "+" Term<val2>            (. if (debug) {Info<<"+Term:"<<val2 << " pos:"<< t->pos << nl;}
-                                   val += val2;
-                                   if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-    | "-" Term<val2>            (. if (debug) {Info<<"-Term:"<<val2<< " pos:"<< t->pos << nl;}
-                                   val -= val2;
-                                   if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-  }
-.
-
-
-/*---------------------------------------------------------------------------*/
-
-Term<scalar& val>               (. scalar val2 = 0;
-                                   if (debug) {Info<<"Term:"<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-=
-  Factor<val>
-  {
-     "*" Factor<val2>           (. if (debug) {Info<<"*Factor:"<<val2<< " pos:"<< t->pos << nl;}
-                                   val *= val2;
-                                   if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-  |  "/" Factor<val2>           (. if (debug) {Info<<"/Factor:"<<val2<< " pos:"<< t->pos << nl;}
-                                   val /= val2;
-                                   if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-                                 .)
-  }
-.
-
-
-/*---------------------------------------------------------------------------*/
-Factor<scalar& val>
-=
-    variable                    (. val = getDictLookup();
-                                   if (debug) {Info<<"lookup:"<<val<< " pos:"<< t->pos << nl;}
-                                 .)
-  | number                      (. val = getScalar();
-                                   if (debug) {Info<<"got num:"<<val<< " pos:"<< t->pos << nl;}
-                                 .)
-  | '-' '(' Expr<val> ')'       (. val = -val;
-                                   if (debug) {Info<<"inv:"<<val<< " pos:"<< t->pos << nl;}
-                                 .)
-  | '(' Expr<val> ')'           (. if (debug){Info<<"got Expr:"<<val<< " pos:"<< t->pos << nl;}
-                                 .)
-.
-
-
-/*---------------------------------------------------------------------------*/
-
-END calcEntry.
-
-// ************************************************************************* //

applications/test/dictionary/calcEntry/calcEntryParser.cpp

@@ -1,339 +0,0 @@
-
-
-#include <wchar.h>
-#include "calcEntryParser.h"
-
-
-namespace Foam {
-namespace functionEntries {
-namespace calcEntryInternal {
-
-
-// ----------------------------------------------------------------------------
-// Parser Implementation
-// ----------------------------------------------------------------------------
-
-void Parser::SynErr(int n) {
-	if (errDist >= minErrDist) errors->SynErr(la->line, la->col, n);
-	errDist = 0;
-}
-
-
-void Parser::SemErr(const wchar_t* msg) {
-	if (errDist >= minErrDist) errors->Error(t->line, t->col, msg);
-	errDist = 0;
-}
-
-
-void Parser::Get() {
-	for (;;) {
-		t = la;
-		la = scanner->Scan();
-		if (la->kind <= maxT) {
-			++errDist;
-			break;
-		}
-
-		if (dummyToken != t) {
-			dummyToken->kind = t->kind;
-			dummyToken->pos = t->pos;
-			dummyToken->col = t->col;
-			dummyToken->line = t->line;
-			dummyToken->next = NULL;
-			coco_string_delete(dummyToken->val);
-			dummyToken->val = coco_string_create(t->val);
-			t = dummyToken;
-		}
-		la = t;
-	}
-}
-
-
-void Parser::Expect(int n) {
-	if (la->kind == n) {
-		Get();
-	}
-	else {
-		SynErr(n);
-	}
-}
-
-
-void Parser::ExpectWeak(int n, int follow) {
-	if (la->kind == n) {
-		Get();
-	}
-	else {
-		SynErr(n);
-		while (!StartOf(follow)) {
-			Get();
-		}
-	}
-}
-
-
-bool Parser::WeakSeparator(int n, int syFol, int repFol) {
-	if (la->kind == n) {
-		Get();
-		return true;
-	}
-	else if (StartOf(repFol)) {
-		return false;
-	}
-	else {
-		SynErr(n);
-		while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
-			Get();
-		}
-		return StartOf(syFol);
-	}
-}
-
-
-void Parser::calcEntry() {
-		val = 0;
-		if (debug){Info<<"start val pos:"<< t->pos << nl;}
-		
-		if (la->kind == 5) {
-			Get();
-			Expr(val);
-			Expect(6);
-			if (debug){
-			   Info<<"end {} at pos:"<< t->pos
-			       <<" val:"<< t->val
-			       <<" len:"<< coco_string_length(t->val)
-			       <<" la pos:"<< la->pos << nl;
-			}
-			// reposition to immediately after the closing '}'
-			scanner->buffer->SetPos
-			(
-			    t->pos + coco_string_length(t->val)
-			);
-			
-		} else if (StartOf(1)) {
-			Expr(val);
-			Expect(0);
-		} else SynErr(14);
-}
-
-void Parser::Expr(scalar& val) {
-		scalar val2 = 0;
-		if (debug) {Info<<"Expr:"<< val<< " pos:"<< t->pos << nl;}
-		
-		Term(val);
-		while (la->kind == 7 || la->kind == 8) {
-			if (la->kind == 7) {
-				Get();
-				Term(val2);
-				if (debug) {Info<<"+Term:"<<val2 << " pos:"<< t->pos << nl;}
-				val += val2;
-				if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-				
-			} else {
-				Get();
-				Term(val2);
-				if (debug) {Info<<"-Term:"<<val2<< " pos:"<< t->pos << nl;}
-				val -= val2;
-				if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-				
-			}
-		}
-}
-
-void Parser::Term(scalar& val) {
-		scalar val2 = 0;
-		if (debug) {Info<<"Term:"<< val<< " pos:"<< t->pos << nl;}
-		
-		Factor(val);
-		while (la->kind == 9 || la->kind == 10) {
-			if (la->kind == 9) {
-				Get();
-				Factor(val2);
-				if (debug) {Info<<"*Factor:"<<val2<< " pos:"<< t->pos << nl;}
-				val *= val2;
-				if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-				
-			} else {
-				Get();
-				Factor(val2);
-				if (debug) {Info<<"/Factor:"<<val2<< " pos:"<< t->pos << nl;}
-				val /= val2;
-				if (debug) {Info<<"="<< val<< " pos:"<< t->pos << nl;}
-				
-			}
-		}
-}
-
-void Parser::Factor(scalar& val) {
-		if (la->kind == 3) {
-			Get();
-			val = getDictLookup();
-			if (debug) {Info<<"lookup:"<<val<< " pos:"<< t->pos << nl;}
-			
-		} else if (la->kind == 4) {
-			Get();
-			val = getScalar();
-			if (debug) {Info<<"got num:"<<val<< " pos:"<< t->pos << nl;}
-			
-		} else if (la->kind == 8) {
-			Get();
-			Expect(11);
-			Expr(val);
-			Expect(12);
-			val = -val;
-			if (debug) {Info<<"inv:"<<val<< " pos:"<< t->pos << nl;}
-			
-		} else if (la->kind == 11) {
-			Get();
-			Expr(val);
-			Expect(12);
-			if (debug){Info<<"got Expr:"<<val<< " pos:"<< t->pos << nl;}
-			
-		} else SynErr(15);
-}
-
-
-
-void Parser::Parse() {
-	t = NULL;
-	if (dummyToken) {    // safety: someone might call Parse() twice
-		delete dummyToken;
-	}
-	la = dummyToken = new Token();
-	la->val = coco_string_create(L"Dummy Token");
-	Get();
-	calcEntry();
-	// let grammar deal with end-of-file expectations
-
-}
-
-
-Parser::Parser(Scanner* scan, Errors* err)
-:
-	dummyToken(NULL),
-	deleteErrorsDestruct_(!err),
-	errDist(minErrDist),
-	scanner(scan),
-	errors(err),
-	t(NULL),
-	la(NULL)
-{
-
-	if (!errors) {   // add in default error handling
-		errors = new Errors();
-	}
-}
-
-
-bool Parser::StartOf(int s) {
-	const bool T = true;
-	const bool x = false;
-
-	static bool set[2][15] = {
-		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
-		{x,x,x,T, T,x,x,x, T,x,x,T, x,x,x}
-	};
-
-
-
-	return set[s][la->kind];
-}
-
-
-Parser::~Parser() {
-	if (deleteErrorsDestruct_) {    // delete default error handling
-		delete errors;
-	}
-	delete dummyToken;
-}
-
-
-// ----------------------------------------------------------------------------
-// Errors Implementation
-// ----------------------------------------------------------------------------
-
-Errors::Errors()
-:
-	count(0)
-{}
-
-
-Errors::~Errors()
-{}
-
-
-void Errors::clear() {
-	count = 0;
-}
-
-
-wchar_t* Errors::strerror(int n)
-{
-	wchar_t* s;
-	switch (n) {
-			case 0: s = coco_string_create(L"EOF expected"); break;
-			case 1: s = coco_string_create(L"ident expected"); break;
-			case 2: s = coco_string_create(L"string expected"); break;
-			case 3: s = coco_string_create(L"variable expected"); break;
-			case 4: s = coco_string_create(L"number expected"); break;
-			case 5: s = coco_string_create(L"\"{\" expected"); break;
-			case 6: s = coco_string_create(L"\"}\" expected"); break;
-			case 7: s = coco_string_create(L"\"+\" expected"); break;
-			case 8: s = coco_string_create(L"\"-\" expected"); break;
-			case 9: s = coco_string_create(L"\"*\" expected"); break;
-			case 10: s = coco_string_create(L"\"/\" expected"); break;
-			case 11: s = coco_string_create(L"\"(\" expected"); break;
-			case 12: s = coco_string_create(L"\")\" expected"); break;
-			case 13: s = coco_string_create(L"??? expected"); break;
-			case 14: s = coco_string_create(L"invalid calcEntry"); break;
-			case 15: s = coco_string_create(L"invalid Factor"); break;
-
-		default:
-		{
-			wchar_t format[20];
-			coco_swprintf(format, 20, L"error %d", n);
-			s = coco_string_create(format);
-		}
-		break;
-	}
-	return s;
-}
-
-
-void Errors::Warning(const wchar_t* msg) {
-	wprintf(L"%ls\n", msg);
-}
-
-
-void Errors::Warning(int line, int col, const wchar_t* msg) {
-	wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
-}
-
-
-void Errors::Error(int line, int col, const wchar_t* msg) {
-	wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
-	count++;
-}
-
-
-void Errors::SynErr(int line, int col, int n) {
-	wchar_t* msg = this->strerror(n);
-	this->Error(line, col, msg);
-	coco_string_delete(msg);
-}
-
-
-void Errors::Exception(const wchar_t* msg) {
-	wprintf(L"%ls", msg);
-	::exit(1);
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // namespace
-} // namespace
-} // namespace
-
-
-// ************************************************************************* //

applications/test/dictionary/calcEntry/calcEntryParser.h

@@ -1,206 +0,0 @@
-
-
-#ifndef COCO_calcEntryPARSER_H__
-#define COCO_calcEntryPARSER_H__
-
-#include "dictionary.H"
-#include "scalar.H"
-#include "error.H"
-#include "wchar.H"
-
-
-#include "calcEntryScanner.h"
-
-namespace Foam {
-namespace functionEntries {
-namespace calcEntryInternal {
-
-
-//! Parser error handing
-class Errors {
-public:
-	int count;      //!< The number of errors detected
-
-	//! Allocate and return a string describing the given error code.
-	/** It is the responsibility of the caller to free this string,
-	 *  eg, with coco_string_delete()
-	 */
-	static wchar_t* strerror(int n);
-
-	Errors();               //!< Construct null - start with no errors
-	virtual ~Errors();      //!< Destructor
-	virtual void clear();   //!< Clear the error count
-
-	//! Handle a general warning 'msg'
-	virtual void Warning(const wchar_t* msg);
-	//! Handle a general warning 'msg'
-	virtual void Warning(int line, int col, const wchar_t* msg);
-	//! Handle general error 'msg' (eg, a semantic error)
-	virtual void Error(int line, int col, const wchar_t* msg);
-	//! Handle syntax error 'n', uses strerror for the message, calls Error()
-	virtual void SynErr(int line, int col, int n);
-	//! Handle a general exception 'msg'
-	virtual void Exception(const wchar_t* msg);
-
-}; // Errors
-
-
-//! A Coco/R Parser
-class Parser {
-private:
-	enum {
-		_EOF=0,
-		_ident=1,
-		_string=2,
-		_variable=3,
-		_number=4,
-	};
-	static const int maxT = 13;
-
-	static const int minErrDist = 2; //!< min. distance before reporting errors
-
-	Token *dummyToken;
-	bool deleteErrorsDestruct_; //!< delete the 'errors' member in destructor
-	int  errDist;
-
-	void SynErr(int n);         //!< Handle syntax error 'n'
-	void Get();
-	void Expect(int n);
-	bool StartOf(int s);
-	void ExpectWeak(int n, int follow);
-	bool WeakSeparator(int n, int syFol, int repFol);
-
-public:
-	Scanner *scanner;
-	Errors  *errors;
-
-	Token *t;                   //!< last recognized token
-	Token *la;                  //!< lookahead token
-
-static const int debug = 0;
-
-    //! The parent dictionary
-    mutable dictionary* dict_;
-
-    //! Track that parent dictionary was set
-    bool hasDict_;
-
-    //! The calculation result
-    scalar val;
-
-
-    //! token -> scalar
-    scalar getScalar() const
-    {
-        return coco_string_toDouble(t->val);
-    }
-
-    //! token -> string
-    std::string getString() const
-    {
-        char* str = coco_string_create_char(t->val);
-        std::string s(str);
-        coco_string_delete(str);
-        return s;
-    }
-
-    //! attach a dictionary
-    void dict(const dictionary& dict)
-    {
-        dict_ = const_cast<dictionary*>(&dict);
-        hasDict_ = true;
-    }
-
-
-    //! lookup dictionary entry
-    scalar getDictLookup() const
-    {
-        scalar dictValue = 0;
-
-        if (!hasDict_)
-        {
-            FatalErrorIn
-            (
-                "calcEntry::getDictEntry() const"
-            )   << "No dictionary attached!"
-                << exit(FatalError);
-
-            return 0;
-        }
-
-        char* chars = coco_string_create_char
-        (
-            t->val,
-            1,
-            (coco_string_length(t->val) - 1)
-        );
-        word keyword(chars);
-        coco_string_delete(chars);
-
-        if (debug)
-        {
-            Info<<"lookup: " << keyword << nl;
-        }
-
-        entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
-        if (entryPtr && !entryPtr->isDict())
-        {
-            if (entryPtr->stream().size() != 1)
-            {
-                FatalErrorIn
-                (
-                    "calcEntry::getDictEntry() const"
-                )   << "keyword " << keyword << " has "
-                    << entryPtr->stream().size() << " values in dictionary "
-                    << exit(FatalError);
-            }
-            entryPtr->stream() >> dictValue;
-        }
-        else
-        {
-            FatalErrorIn
-            (
-                "calcEntry::getDictEntry() const"
-            )   << "keyword " << keyword << " is undefined in dictionary "
-                << exit(FatalError);
-        }
-
-
-        return dictValue;
-    }
-
-    scalar Result() const
-    {
-        return val;
-    }
-
-
-/*---------------------------------------------------------------------------*/
-
-
-
-	//! Construct for the specified scanner
-	/**
-	 *  Use the default error handling, or optionally provide an error
-	 *  handler, which will not be deleted upon destruction.
-	 */
-	Parser(Scanner* scan, Errors* err = 0);
-	~Parser();      //!< Destructor - cleanup errors and dummyToken
-	void SemErr(const wchar_t* msg);    //!< Handle semantic error
-
-	void calcEntry();
-	void Expr(scalar& val);
-	void Term(scalar& val);
-	void Factor(scalar& val);
-
-	void Parse();                       //!< Execute the parse operation
-
-}; // end Parser
-
-} // namespace
-} // namespace
-} // namespace
-
-
-#endif // COCO_calcEntryPARSER_H__
-

applications/test/dictionary/calcEntry/calcEntryScanner.cpp

@@ -1,932 +0,0 @@
-
-
-#include <sstream>
-
-#include "calcEntryScanner.h"
-
-// values for the file stream buffering
-#define MIN_BUFFER_LENGTH 1024        // 1KB
-#define MAX_BUFFER_LENGTH (64*MIN_BUFFER_LENGTH)   // 64KB
-// value for the heap management
-#define HEAP_BLOCK_SIZE   (64*1024)   // 64KB
-
-
-namespace Foam {
-namespace functionEntries {
-namespace calcEntryInternal {
-
-
-// * * * * * * * * * *  Wide Character String Routines * * * * * * * * * * * //
-
-// string handling, wide character
-
-wchar_t* coco_string_create(const wchar_t* str) {
-	int len = coco_string_length(str);
-	wchar_t* dest = new wchar_t[len + 1];
-	if (len) {
-		wcsncpy(dest, str, len);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-wchar_t* coco_string_create(const wchar_t* str, int index, int length) {
-	int len = coco_string_length(str);
-	if (len) {
-		len = length;
-	}
-	wchar_t* dest = new wchar_t[len + 1];
-	if (len) {
-		wcsncpy(dest, &(str[index]), len);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-
-wchar_t* coco_string_create_lower(const wchar_t* str) {
-	if (!str) { return NULL; }
-	return coco_string_create_lower(str, 0, wcslen(str));
-}
-
-
-wchar_t* coco_string_create_lower(const wchar_t* str, int index, int len) {
-	if (!str) { return NULL; }
-	wchar_t* dest = new wchar_t[len + 1];
-
-	for (int i = 0; i < len; i++) {
-		const wchar_t ch = str[index + i];
-		if ((L'A' <= ch) && (ch <= L'Z')) {
-			dest[i] = ch - (L'A' - L'a');
-		}
-		else {
-			dest[i] = ch;
-		}
-	}
-	dest[len] = L'\0';
-	return dest;
-}
-
-
-wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2) {
-	int str1Len = coco_string_length(str1);
-	int str2Len = coco_string_length(str2);
-
-	wchar_t* dest = new wchar_t[str1Len + str2Len + 1];
-
-	if (str1Len) { wcscpy(dest, str1); }
-	if (str2Len) { wcscpy(dest + str1Len, str2); }
-
-	dest[str1Len + str2Len] = 0;
-	return dest;
-}
-
-wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t ch) {
-	int len = coco_string_length(str1);
-	wchar_t* dest = new wchar_t[len + 2];
-	wcsncpy(dest, str1, len);   // or use if (len) { wcscpy(dest, str1); }
-	dest[len] = ch;
-	dest[len + 1] = 0;
-	return dest;
-}
-
-void coco_string_delete(wchar_t* &str) {
-	delete [] str;
-	str = NULL;
-}
-
-int coco_string_length(const wchar_t* str) {
-	return str ? wcslen(str) : 0;
-}
-
-bool coco_string_endswith(const wchar_t* str, const wchar_t* endstr) {
-	int strLen = wcslen(str);
-	int endLen = wcslen(endstr);
-	return (endLen <= strLen) && (wcscmp(str + strLen - endLen, endstr) == 0);
-}
-
-int coco_string_indexof(const wchar_t* str, const wchar_t ch) {
-	const wchar_t* fnd = wcschr(str, ch);
-	return fnd ? (fnd - str) : -1;
-}
-
-int coco_string_lastindexof(const wchar_t* str, const wchar_t ch) {
-	const wchar_t* fnd = wcsrchr(str, ch);
-	return fnd ? (fnd - str) : -1;
-}
-
-void coco_string_merge(wchar_t* &dest, const wchar_t* str) {
-	if (!str) { return; }
-	wchar_t* newstr = coco_string_create_append(dest, str);
-	delete [] dest;
-	dest = newstr;
-}
-
-bool coco_string_equal(const wchar_t* str1, const wchar_t* str2) {
-	return wcscmp(str1, str2) == 0;
-}
-
-int coco_string_compareto(const wchar_t* str1, const wchar_t* str2) {
-	return wcscmp(str1, str2);
-}
-
-int coco_string_hash(const wchar_t* str) {
-	int h = 0;
-	if (!str) { return 0; }
-	while (*str != 0) {
-		h = (h * 7) ^ *str;
-		++str;
-	}
-	if (h < 0) { h = -h; }
-	return h;
-}
-
-
-double coco_string_toDouble(const wchar_t* str)
-{
-	return str ? wcstod(str, NULL) : 0;
-}
-
-float coco_string_toFloat(const wchar_t* str)
-{
-	return str ? wcstof(str, NULL) : 0;
-}
-
-
-
-//
-// string handling, byte character
-//
-
-wchar_t* coco_string_create(const char* str) {
-	int len = str ? strlen(str) : 0;
-	wchar_t* dest = new wchar_t[len + 1];
-	for (int i = 0; i < len; ++i) {
-		dest[i] = wchar_t(str[i]);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-wchar_t* coco_string_create(const char* str, int index, int length) {
-	int len = str ? length : 0;
-	wchar_t* dest = new wchar_t[len + 1];
-	for (int i = 0; i < len; ++i) {
-		dest[i] = wchar_t(str[index + i]);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-
-char* coco_string_create_char(const wchar_t* str) {
-	int len = coco_string_length(str);
-	char *dest = new char[len + 1];
-	for (int i = 0; i < len; ++i)
-	{
-		dest[i] = char(str[i]);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-char* coco_string_create_char(const wchar_t* str, int index, int length) {
-	int len = coco_string_length(str);
-	if (len) {
-		len = length;
-	}
-	char *dest = new char[len + 1];
-	for (int i = 0; i < len; ++i) {
-		dest[i] = char(str[index + i]);
-	}
-	dest[len] = 0;
-	return dest;
-}
-
-
-void coco_string_delete(char* &str) {
-	delete [] str;
-	str = NULL;
-}
-
-
-double coco_string_toDouble(const char* str)
-{
-	return str ? strtod(str, NULL) : 0;
-}
-
-float coco_string_toFloat(const char* str)
-{
-	return str ? strtof(str, NULL) : 0;
-}
-
-
-// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
-
-
-Token::Token()
-:
-    kind(0),
-    pos(0),
-    col(0),
-    line(0),
-    val(NULL),
-    next(NULL)
-{}
-
-
-// Note: this delete may not be correct if the token was actually
-// allocated by the internal heap mechanism
-Token::~Token() {
-	coco_string_delete(val);
-}
-
-
-// ----------------------------------------------------------------------------
-// Buffer Implementation
-// ----------------------------------------------------------------------------
-
-Buffer::Buffer(Buffer* b)
-:
-	buf(b->buf),
-	bufCapacity(b->bufCapacity),
-	bufLen(b->bufLen),
-	bufPos(b->bufPos),
-	bufStart(b->bufStart),
-	fileLen(b->fileLen),
-	cStream(b->cStream),
-	stdStream(b->stdStream),
-	isUserStream_(b->isUserStream_)
-{
-	// avoid accidental deletion on any of these members
-	b->buf = NULL;
-	b->cStream = NULL;
-	b->stdStream = NULL;
-}
-
-
-Buffer::Buffer(FILE* istr, bool isUserStream)
-:
-	buf(NULL),
-	bufCapacity(0),
-	bufLen(0),
-	bufPos(0),
-	bufStart(0),
-	fileLen(0),
-	cStream(istr),
-	stdStream(NULL),
-	isUserStream_(isUserStream)
-{
-// ensure binary read on windows
-#if _MSC_VER >= 1300
-	_setmode(_fileno(cStream), _O_BINARY);
-#endif
-
-	if (CanSeek()) {
-		fseek(cStream, 0, SEEK_END);
-		fileLen = ftell(cStream);
-		fseek(cStream, 0, SEEK_SET);
-		bufLen = (fileLen < MAX_BUFFER_LENGTH) ? fileLen : MAX_BUFFER_LENGTH;
-		bufStart = INT_MAX; // nothing in the buffer so far
-	}
-
-	bufCapacity = (bufLen > 0) ? bufLen : MIN_BUFFER_LENGTH;
-	buf = new unsigned char[bufCapacity];
-	if (fileLen > 0) SetPos(0);          // setup buffer to position 0 (start)
-	else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
-	if (bufLen == fileLen && CanSeek()) Close();
-}
-
-
-Buffer::Buffer(std::istream* istr, bool isUserStream)
-:
-	buf(NULL),
-	bufCapacity(0),
-	bufLen(0),
-	bufPos(0),
-	bufStart(0),
-	fileLen(0),
-	cStream(NULL),
-	stdStream(istr),
-	isUserStream_(isUserStream)
-{
-	// ensure binary read on windows
-#if _MSC_VER >= 1300
-	// TODO
-#endif
-}
-
-
-Buffer::Buffer(std::string& str)
-:
-	buf(NULL),
-	bufCapacity(0),
-	bufLen(0),
-	bufPos(0),
-	bufStart(0),
-	fileLen(0),
-	cStream(NULL),
-	stdStream(new std::istringstream(str)),
-	isUserStream_(false)
-{}
-
-
-Buffer::Buffer(const unsigned char* chars, int len)
-:
-	buf(new unsigned char[len]),
-	bufCapacity(len),
-	bufLen(len),
-	bufPos(0),
-	bufStart(0),
-	fileLen(len),
-	cStream(NULL),
-	stdStream(NULL),
-	isUserStream_(false)
-{
-	memcpy(this->buf, chars, len*sizeof(char));
-}
-
-
-Buffer::Buffer(const char* chars, int len)
-:
-	buf(new unsigned char[len]),
-	bufCapacity(len),
-	bufLen(len),
-	bufPos(0),
-	bufStart(0),
-	fileLen(len),
-	cStream(NULL),
-	stdStream(NULL),
-	isUserStream_(false)
-{
-	memcpy(this->buf, chars, len*sizeof(char));
-}
-
-
-Buffer::~Buffer() {
-	Close();
-	if (buf) {
-		delete [] buf;
-		buf = NULL;
-	}
-}
-
-
-void Buffer::Close() {
-	if (!isUserStream_) {
-		if (cStream) {
-			fclose(cStream);
-			cStream = NULL;
-		}
-		else if (stdStream) {
-			delete stdStream;
-			stdStream = 0;
-		}
-	}
-}
-
-
-int Buffer::Read() {
-	if (stdStream)
-	{
-		int ch = stdStream->get();
-		if (stdStream->eof())
-		{
-			return EoF;
-		}
-		return ch;
-	}
-
-	if (bufPos < bufLen) {
-		return buf[bufPos++];
-	} else if (GetPos() < fileLen) {
-		SetPos(GetPos()); // shift buffer start to Pos
-		return buf[bufPos++];
-	} else if (cStream && !CanSeek() && (ReadNextStreamChunk() > 0)) {
-		return buf[bufPos++];
-	} else {
-		return EoF;
-	}
-}
-
-
-int UTF8Buffer::Read() {
-	int ch;
-	do {
-		ch = Buffer::Read();
-		// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
-	} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EoF));
-	if (ch < 128 || ch == EoF) {
-		// nothing to do, first 127 chars are the same in ascii and utf8
-		// 0xxxxxxx or end of file character
-	} else if ((ch & 0xF0) == 0xF0) {
-		// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-		int c1 = ch & 0x07; ch = Buffer::Read();
-		int c2 = ch & 0x3F; ch = Buffer::Read();
-		int c3 = ch & 0x3F; ch = Buffer::Read();
-		int c4 = ch & 0x3F;
-		ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
-	} else if ((ch & 0xE0) == 0xE0) {
-		// 1110xxxx 10xxxxxx 10xxxxxx
-		int c1 = ch & 0x0F; ch = Buffer::Read();
-		int c2 = ch & 0x3F; ch = Buffer::Read();
-		int c3 = ch & 0x3F;
-		ch = (((c1 << 6) | c2) << 6) | c3;
-	} else if ((ch & 0xC0) == 0xC0) {
-		// 110xxxxx 10xxxxxx
-		int c1 = ch & 0x1F; ch = Buffer::Read();
-		int c2 = ch & 0x3F;
-		ch = (c1 << 6) | c2;
-	}
-	return ch;
-}
-
-
-int Buffer::Peek() {
-	int curPos = GetPos();
-	int ch = Read();
-	SetPos(curPos);
-	return ch;
-}
-
-
-int Buffer::GetPos() const {
-	if (stdStream)
-	{
-		return stdStream->tellg();
-	}
-
-	return bufPos + bufStart;
-}
-
-
-void Buffer::SetPos(int value) {
-	if (stdStream)
-	{
-		stdStream->seekg(value, std::ios::beg);
-		return;
-	}
-
-	if ((value >= fileLen) && cStream && !CanSeek()) {
-		// Wanted position is after buffer and the stream
-		// is not seek-able e.g. network or console,
-		// thus we have to read the stream manually till
-		// the wanted position is in sight.
-		while ((value >= fileLen) && (ReadNextStreamChunk() > 0))
-		{}
-	}
-
-	if ((value < 0) || (value > fileLen)) {
-		wprintf(L"--- buffer out of bounds access, position: %d\n", value);
-		::exit(1);
-	}
-
-	if ((value >= bufStart) && (value < (bufStart + bufLen))) { // already in buffer
-		bufPos = value - bufStart;
-	} else if (cStream) { // must be swapped in
-		fseek(cStream, value, SEEK_SET);
-		bufLen = fread(buf, sizeof(char), bufCapacity, cStream);
-		bufStart = value; bufPos = 0;
-	} else {
-		bufPos = fileLen - bufStart; // make Pos return fileLen
-	}
-}
-
-
-// Read the next chunk of bytes from the stream, increases the buffer
-// if needed and updates the fields fileLen and bufLen.
-// Returns the number of bytes read.
-int Buffer::ReadNextStreamChunk() {
-	int freeLen = bufCapacity - bufLen;
-	if (freeLen == 0) {
-		// in the case of a growing input stream
-		// we can neither seek in the stream, nor can we
-		// foresee the maximum length, thus we must adapt
-		// the buffer size on demand.
-		bufCapacity = bufLen * 2;
-		unsigned char *newBuf = new unsigned char[bufCapacity];
-		memcpy(newBuf, buf, bufLen*sizeof(char));
-		delete [] buf;
-		buf = newBuf;
-		freeLen = bufLen;
-	}
-	int read = fread(buf + bufLen, sizeof(char), freeLen, cStream);
-	if (read > 0) {
-		fileLen = bufLen = (bufLen + read);
-		return read;
-	}
-	// end of stream reached
-	return 0;
-}
-
-
-bool Buffer::CanSeek() const {
-	return cStream && (ftell(cStream) != -1);
-}
-
-
-// ----------------------------------------------------------------------------
-// Scanner Implementation
-// ----------------------------------------------------------------------------
-
-Scanner::Scanner(FILE* istr)
-:
-	buffer(new Buffer(istr, true))
-{
-	Init();
-}
-
-
-Scanner::Scanner(std::istream& istr)
-:
-	buffer(new Buffer(&istr, true))
-{
-	Init();
-}
-
-
-Scanner::Scanner(const wchar_t* fileName) {
-	char *chFileName = coco_string_create_char(fileName);
-	FILE* istr;
-	if ((istr = fopen(chFileName, "rb")) == NULL) {
-		wprintf(L"--- Cannot open file %ls\n", fileName);
-		::exit(1);
-	}
-	coco_string_delete(chFileName);
-	buffer = new Buffer(istr, false);
-	Init();
-}
-
-
-Scanner::Scanner(const unsigned char* buf, int len)
-:
-	buffer(new Buffer(buf, len))
-{
-	Init();
-}
-
-
-Scanner::Scanner(const char* buf, int len)
-:
-	buffer(new Buffer(buf, len))
-{
-	Init();
-}
-
-
-Scanner::~Scanner() {
-	char* cur = reinterpret_cast<char*>(firstHeap);
-
-	while (cur) {
-		cur = *(reinterpret_cast<char**>(cur + HEAP_BLOCK_SIZE));
-		free(firstHeap);
-		firstHeap = cur;
-	}
-	delete [] tval;
-	delete buffer;
-}
-
-
-void Scanner::Init() {
-	for (int i = 65; i <= 90; ++i) start.set(i, 1);
-	for (int i = 97; i <= 122; ++i) start.set(i, 1);
-	for (int i = 36; i <= 36; ++i) start.set(i, 5);
-	start.set(45, 20);
-	for (int i = 48; i <= 57; ++i) start.set(i, 9);
-	start.set(34, 2);
-	start.set(46, 7);
-	start.set(123, 14);
-	start.set(125, 15);
-	start.set(43, 21);
-	start.set(42, 16);
-	start.set(47, 17);
-	start.set(40, 18);
-	start.set(41, 19);
-	start.set(Buffer::EoF, -1);
-
-
-
-	tvalLength = 128;
-	tval = new wchar_t[tvalLength]; // text of current token
-
-	// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
-	heap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
-	firstHeap = heap;
-	heapEnd =
-		reinterpret_cast<void**>
-		(reinterpret_cast<char*>(heap) + HEAP_BLOCK_SIZE);
-	*heapEnd = 0;
-	heapTop = heap;
-	if (sizeof(Token) > HEAP_BLOCK_SIZE) {
-		wprintf(L"--- Too small HEAP_BLOCK_SIZE\n");
-		::exit(1);
-	}
-
-	pos = -1; line = 1; col = 0;
-	oldEols = 0;
-	NextCh();
-	if (ch == 0xEF) { // check optional byte order mark for UTF-8
-		NextCh(); int ch1 = ch;
-		NextCh(); int ch2 = ch;
-		if (ch1 != 0xBB || ch2 != 0xBF) {
-			wprintf(L"Illegal byte order mark at start of file");
-			::exit(1);
-		}
-		Buffer *oldBuf = buffer;
-		buffer = new UTF8Buffer(buffer); col = 0;
-		delete oldBuf; oldBuf = NULL;
-		NextCh();
-	}
-
-
-	pt = tokens = CreateToken(); // first token is a dummy
-}
-
-
-void Scanner::NextCh() {
-	if (oldEols > 0) {
-		ch = EOL;
-		oldEols--;
-	}
-	else {
-		pos = buffer->GetPos();
-		ch = buffer->Read(); col++;
-		// replace isolated '\r' by '\n' in order to make
-		// eol handling uniform across Windows, Unix and Mac
-		if (ch == L'\r' && buffer->Peek() != L'\n') ch = EOL;
-		if (ch == EOL) { line++; col = 0; }
-	}
-
-}
-
-
-void Scanner::AddCh() {
-	if (tlen >= tvalLength) {
-		tvalLength *= 2;
-		wchar_t *newBuf = new wchar_t[tvalLength];
-		memcpy(newBuf, tval, tlen*sizeof(wchar_t));
-		delete [] tval;
-		tval = newBuf;
-	}
-	if (ch != Buffer::EoF) {
-		tval[tlen++] = ch;
-		NextCh();
-	}
-}
-
-
-
-bool Scanner::Comment0() {
-	int level = 1, pos0 = pos, line0 = line, col0 = col;
-	NextCh();
-	if (ch == L'/') {
-		NextCh();
-		for(;;) {
-			if (ch == 10) {
-				level--;
-				if (level == 0) { oldEols = line - line0; NextCh(); return true; }
-				NextCh();
-			} else if (ch == buffer->EoF) return false;
-			else NextCh();
-		}
-	} else {
-		buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
-	}
-	return false;
-}
-
-bool Scanner::Comment1() {
-	int level = 1, pos0 = pos, line0 = line, col0 = col;
-	NextCh();
-	if (ch == L'*') {
-		NextCh();
-		for(;;) {
-			if (ch == L'*') {
-				NextCh();
-				if (ch == L'/') {
-					level--;
-					if (level == 0) { oldEols = line - line0; NextCh(); return true; }
-					NextCh();
-				}
-			} else if (ch == L'/') {
-				NextCh();
-				if (ch == L'*') {
-					level++; NextCh();
-				}
-			} else if (ch == buffer->EoF) return false;
-			else NextCh();
-		}
-	} else {
-		buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
-	}
-	return false;
-}
-
-
-void Scanner::CreateHeapBlock() {
-	char* cur = reinterpret_cast<char*>(firstHeap);
-
-	// release unused blocks
-	while
-	(
-            (reinterpret_cast<char*>(tokens) < cur)
-         || (reinterpret_cast<char*>(tokens) > (cur + HEAP_BLOCK_SIZE))
-        ) {
-		cur = *(reinterpret_cast<char**>(cur + HEAP_BLOCK_SIZE));
-		free(firstHeap);
-		firstHeap = cur;
-	}
-
-	// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
-	void* newHeap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
-	*heapEnd = newHeap;
-	heapEnd =
-		reinterpret_cast<void**>
-		(reinterpret_cast<char*>(newHeap) + HEAP_BLOCK_SIZE);
-	*heapEnd = 0;
-	heap = newHeap;
-	heapTop = heap;
-}
-
-
-Token* Scanner::CreateToken() {
-	const int reqMem = sizeof(Token);
-	if
-	(
-	    (reinterpret_cast<char*>(heapTop) + reqMem)
-	 >= reinterpret_cast<char*>(heapEnd)
-	) {
-		CreateHeapBlock();
-	}
-	// token 'occupies' heap starting at heapTop
-	Token* tok = reinterpret_cast<Token*>(heapTop);
-	// increment past this part of the heap, which is now used
-	heapTop =
-		reinterpret_cast<void*>
-		(reinterpret_cast<char*>(heapTop) + reqMem);
-	tok->val  = NULL;
-	tok->next = NULL;
-	return tok;
-}
-
-
-void Scanner::AppendVal(Token* tok) {
-	const int reqMem = (tlen + 1) * sizeof(wchar_t);
-	if
-	(
-	    (reinterpret_cast<char*>(heapTop) + reqMem)
-	 >= reinterpret_cast<char*>(heapEnd)
-	) {
-		if (reqMem > HEAP_BLOCK_SIZE) {
-			wprintf(L"--- Too long token value\n");
-			::exit(1);
-		}
-		CreateHeapBlock();
-	}
-
-	// add text value from heap
-	tok->val = reinterpret_cast<wchar_t*>(heapTop);
-
-	// increment past this part of the heap, which is now used
-	heapTop =
-		reinterpret_cast<void*>
-		(reinterpret_cast<char*>(heapTop) + reqMem);
-
-	// copy the currently parsed tval into the token
-	wcsncpy(tok->val, tval, tlen);
-	tok->val[tlen] = L'\0';
-}
-
-
-Token* Scanner::NextToken() {
-	while (ch == ' ' ||
-			(ch >= 9 && ch <= 10) || ch == 13
-	) NextCh();
-	if ((ch == L'/' && Comment0()) || (ch == L'/' && Comment1())) return NextToken();
-	t = CreateToken();
-	t->pos = pos; t->col = col; t->line = line;
-	int state = start.state(ch);
-	tlen = 0; AddCh();
-
-	switch (state) {
-		case -1: { t->kind = eofSym; break; } // NextCh already done
-		case 0: { t->kind = noSym; break; }   // NextCh already done
-		case 1:
-			case_1:
-			if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_1;}
-			else {t->kind = 1; break;}
-		case 2:
-			case_2:
-			if (ch <= 9 || (ch >= 11 && ch <= 12) || (ch >= 14 && ch <= L'!') || (ch >= L'#' && ch <= L'[') || (ch >= L']' && ch <= 65535)) {AddCh(); goto case_2;}
-			else if (ch == L'"') {AddCh(); goto case_4;}
-			else if (ch == 92) {AddCh(); goto case_3;}
-			else {t->kind = noSym; break;}
-		case 3:
-			case_3:
-			if ((ch >= L' ' && ch <= L'~')) {AddCh(); goto case_2;}
-			else {t->kind = noSym; break;}
-		case 4:
-			case_4:
-			{t->kind = 2; break;}
-		case 5:
-			if ((ch >= L'A' && ch <= L'Z') || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
-			else {t->kind = noSym; break;}
-		case 6:
-			case_6:
-			if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
-			else {t->kind = 3; break;}
-		case 7:
-			case_7:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
-			else {t->kind = noSym; break;}
-		case 8:
-			case_8:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
-			else {t->kind = 4; break;}
-		case 9:
-			case_9:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_9;}
-			else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
-			else if (ch == L'.') {AddCh(); goto case_13;}
-			else {t->kind = 4; break;}
-		case 10:
-			case_10:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
-			else if (ch == L'+' || ch == L'-') {AddCh(); goto case_11;}
-			else {t->kind = noSym; break;}
-		case 11:
-			case_11:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
-			else {t->kind = noSym; break;}
-		case 12:
-			case_12:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
-			else {t->kind = 4; break;}
-		case 13:
-			case_13:
-			if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_13;}
-			else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
-			else {t->kind = 4; break;}
-		case 14:
-			{t->kind = 5; break;}
-		case 15:
-			{t->kind = 6; break;}
-		case 16:
-			{t->kind = 9; break;}
-		case 17:
-			{t->kind = 10; break;}
-		case 18:
-			{t->kind = 11; break;}
-		case 19:
-			{t->kind = 12; break;}
-		case 20:
-			if (ch == L'.') {AddCh(); goto case_7;}
-			else {t->kind = 8; break;}
-		case 21:
-			if (ch == L'.') {AddCh(); goto case_7;}
-			else {t->kind = 7; break;}
-
-	}
-	AppendVal(t);
-	return t;
-}
-
-
-// get the next token (possibly a token already seen during peeking)
-Token* Scanner::Scan() {
-	if (tokens->next == NULL) {
-		return pt = tokens = NextToken();
-	} else {
-		pt = tokens = tokens->next;
-		return tokens;
-	}
-}
-
-
-// peek for the next token, ignore pragmas
-Token* Scanner::Peek() {
-	do {
-		if (pt->next == NULL) {
-			pt->next = NextToken();
-		}
-		pt = pt->next;
-	} while (pt->kind > maxT); // skip pragmas
-
-	return pt;
-}
-
-
-// make sure that peeking starts at the current scan position
-void Scanner::ResetPeek() {
-	pt = tokens;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // namespace
-} // namespace
-} // namespace
-
-
-// ************************************************************************* //

applications/test/dictionary/calcEntry/calcEntryScanner.h

@@ -1,398 +0,0 @@
-
-
-#ifndef COCO_calcEntrySCANNER_H__
-#define COCO_calcEntrySCANNER_H__
-
-#include <climits>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cwchar>
-#include <string>
-#include <fstream>
-#include <iostream>
-
-// io.h and fcntl are used to ensure binary read from streams on windows
-#if _MSC_VER >= 1300
-#include <io.h>
-#include <fcntl.h>
-#endif
-
-#if _MSC_VER >= 1400
-#define coco_swprintf swprintf_s
-#elif _MSC_VER >= 1300
-#define coco_swprintf _snwprintf
-#else
-// assume every other compiler knows swprintf
-#define coco_swprintf swprintf
-#endif
-
-
-#define COCO_WCHAR_MAX    65535
-
-
-namespace Foam {
-namespace functionEntries {
-namespace calcEntryInternal {
-
-
-
-// * * * * * * * * * *  Wide Character String Routines * * * * * * * * * * * //
-
-//
-// string handling, wide character
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-//! Create by copying str
-wchar_t* coco_string_create(const wchar_t* str);
-
-//! Create a substring of str starting at index and length characters long
-wchar_t* coco_string_create(const wchar_t* str, int index, int length);
-
-//! Create a lowercase string from str
-wchar_t* coco_string_create_lower(const wchar_t* str);
-
-//! Create a lowercase substring from str starting at index and length characters long
-wchar_t* coco_string_create_lower(const wchar_t* str, int index, int length);
-
-//! Create a string by concatenating str1 and str2
-wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2);
-
-//! Create a string by concatenating a character to the end of str
-wchar_t* coco_string_create_append(const wchar_t* str, const wchar_t ch);
-
-//! Free storage and nullify the argument
-void  coco_string_delete(wchar_t* &str);
-
-//! The length of the str, or 0 if the str is NULL
-int   coco_string_length(const wchar_t* str);
-
-//! Return true if the str ends with the endstr
-bool  coco_string_endswith(const wchar_t* str, const wchar_t* endstr);
-
-//! Return the index of the first occurrence of ch.
-//  Return -1 if nothing is found.
-int   coco_string_indexof(const wchar_t* str, const wchar_t ch);
-
-//! Return the index of the last occurrence of ch.
-//  Return -1 if nothing is found.
-int   coco_string_lastindexof(const wchar_t* str, const wchar_t ch);
-
-//! Append str to dest
-void  coco_string_merge(wchar_t* &dest, const wchar_t* str);
-
-//! Compare strings, return true if they are equal
-bool  coco_string_equal(const wchar_t* str1, const wchar_t* str2);
-
-//! Compare strings, return 0 if they are equal
-int   coco_string_compareto(const wchar_t* str1, const wchar_t* str2);
-
-//! Simple string hashing function
-int   coco_string_hash(const wchar_t* str);
-
-//
-// String conversions
-// ~~~~~~~~~~~~~~~~~~
-
-//! Convert wide string to double
-double coco_string_toDouble(const wchar_t* str);
-
-//! Convert wide string to float
-float coco_string_toFloat(const wchar_t* str);
-
-//
-// String handling, byte character
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-//! Create by copying byte str
-wchar_t* coco_string_create(const char* str);
-
-//! Create a substring of byte str starting at index and length characters long
-wchar_t* coco_string_create(const char* str, int index, int length);
-
-//! Create a byte string by copying str
-char* coco_string_create_char(const wchar_t* str);
-
-//! Create a byte substring of str starting at index and length characters long
-char* coco_string_create_char(const wchar_t* str, int index, int length);
-
-//! Free storage and nullify the argument
-void  coco_string_delete(char* &str);
-
-
-//
-// String conversions, byte character
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-//! Convert byte string to double
-double coco_string_toDouble(const char* str);
-
-//! Convert byte string to float
-float coco_string_toFloat(const char* str);
-
-// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
-
-
-//! Scanner Token
-class Token
-{
-public:
-	int kind;       //!< token kind
-	int pos;        //!< token position in the source text (starting at 0)
-	int col;        //!< token column (starting at 1)
-	int line;       //!< token line (starting at 1)
-	wchar_t* val;   //!< token value
-	Token *next;    //!< Peek tokens are kept in linked list
-
-	Token();        //!< Construct null
-	~Token();       //!< Destructor - cleanup allocated val??
-};
-
-
-//! Scanner Buffer
-//
-//! This Buffer supports the following cases:
-//! -# seekable stream (file)
-//!    -# whole stream in buffer
-//!    -# part of stream in buffer
-//! -# non seekable stream (network, console)
-class Buffer {
-private:
-	unsigned char *buf; //!< input buffer
-	int bufCapacity;    //!< capacity of buf
-	int bufLen;         //!< length of buffer
-	int bufPos;         //!< current position in buffer
-	int bufStart;       //!< position of first byte in buffer relative to input stream
-	int fileLen;        //!< length of input stream (may change if the stream is no file)
-	FILE* cStream;      //!< input stdio stream (normally seekable)
-	std::istream* stdStream;  //!< STL std stream (seekable)
-	bool isUserStream_;  //!< was the stream opened by the user?
-
-	int ReadNextStreamChunk();
-	bool CanSeek() const; //!< true if stream can be seeked otherwise false
-
-protected:
-	Buffer(Buffer*);    //!< for the UTF8Buffer
-
-public:
-	static const int EoF = COCO_WCHAR_MAX + 1;
-
-	//! Attach buffer to a stdio stream.
-	//! User streams are not closed in the destructor
-	Buffer(FILE*, bool isUserStream = true);
-
-	//! Attach buffer to an STL std stream
-	//! User streams are not closed in the destructor
-	explicit Buffer(std::istream*, bool isUserStream = true);
-
-	//! Copy buffer contents from constant string
-	//! Handled internally as an istringstream
-	explicit Buffer(std::string&);
-
-	//! Copy buffer contents from constant character string
-	Buffer(const unsigned char* chars, int len);
-	//! Copy buffer contents from constant character string
-	Buffer(const char* chars, int len);
-
-	//! Close stream (but not user streams) and free buf (if any)
-	virtual ~Buffer();
-
-	virtual void Close();   //!< Close stream (but not user streams)
-	virtual int Read();     //!< Get character from stream or buffer
-	virtual int Peek();     //!< Peek character from stream or buffer
-
-	virtual int GetPos() const;
-	virtual void SetPos(int value);
-};
-
-
-//! A Scanner buffer that handles UTF-8 characters
-class UTF8Buffer : public Buffer {
-public:
-	UTF8Buffer(Buffer* b) : Buffer(b) {}
-	virtual int Read();
-};
-
-
-//------------------------------------------------------------------------------
-// StartStates
-//------------------------------------------------------------------------------
-//! maps characters (integers) to start states of tokens
-class StartStates {
-private:
-	class Elem {
-	public:
-		int key, val;
-		Elem *next;
-		Elem(int k, int v) :
-			key(k), val(v), next(0)
-		{}
-	};
-
-	Elem **tab;
-
-public:
-	StartStates() :
-		tab(new Elem*[128])
-	{
-		memset(tab, 0, 128 * sizeof(Elem*));
-	}
-
-	virtual ~StartStates() {
-		for (int i = 0; i < 128; ++i) {
-			Elem *e = tab[i];
-			while (e) {
-				Elem *next = e->next;
-				delete e;
-				e = next;
-			}
-		}
-		delete [] tab;
-	}
-
-	void set(int key, int val) {
-		Elem *e = new Elem(key, val);
-		int k = unsigned(key) % 128;
-		e->next = tab[k];
-		tab[k] = e;
-	}
-
-	int state(int key) {
-		Elem *e = tab[unsigned(key) % 128];
-		while (e && e->key != key) e = e->next;
-		return e ? e->val : 0;
-	}
-};
-
-
-//------------------------------------------------------------------------------
-// KeywordMap
-//------------------------------------------------------------------------------
-//! maps strings to integers (identifiers to keyword kinds)
-class KeywordMap {
-private:
-	class Elem {
-	public:
-		wchar_t *key;
-		int val;
-		Elem *next;
-		Elem(const wchar_t *k, int v) :
-			key(coco_string_create(k)), val(v), next(0)
-		{}
-		virtual ~Elem() {
-			coco_string_delete(key);
-		}
-	};
-
-	Elem **tab;
-
-public:
-	KeywordMap() :
-		tab(new Elem*[128])
-	{
-		memset(tab, 0, 128 * sizeof(Elem*));
-	}
-
-	virtual ~KeywordMap() {
-		for (int i = 0; i < 128; ++i) {
-			Elem *e = tab[i];
-			while (e) {
-				Elem *next = e->next;
-				delete e;
-				e = next;
-			}
-		}
-		delete [] tab;
-	}
-
-	void set(const wchar_t *key, int val) {
-		Elem *e = new Elem(key, val);
-		const int k = coco_string_hash(key) % 128;
-		e->next = tab[k];
-		tab[k] = e;
-	}
-
-	int get(const wchar_t *key, int defaultVal) {
-		Elem *e = tab[coco_string_hash(key) % 128];
-		while (e && !coco_string_equal(e->key, key)) e = e->next;
-		return e ? e->val : defaultVal;
-	}
-};
-
-
-//! A Coco/R Scanner
-class Scanner {
-private:
-	static const int maxT = 13;
-	static const int noSym = 13;
-
-	static const int eofSym = 0;    //!< end-of-file token id
-	static const char EOL = '\n';   //!< end-of-line character
-
-	void *firstHeap;  //!< the start of the heap management
-	void *heap;       //!< the currently active block
-	void *heapTop;    //!< the top of the heap
-	void **heapEnd;   //!< the end of the last heap block
-
-	StartStates start;   //!< A map of start states for particular characters
-	KeywordMap keywords; //!< A hash of keyword literals to token kind
-
-	Token *t;         //!< current token
-	wchar_t *tval;    //!< text of current token
-	int tvalLength;   //!< maximum capacity (length) for tval
-	int tlen;         //!< length of tval
-
-	Token *tokens;    //!< list of tokens already peeked (first token is a dummy)
-	Token *pt;        //!< current peek token
-
-	int ch;           //!< current input character
-
-	int pos;          //!< byte position of current character
-	int line;         //!< line number of current character
-	int col;          //!< column number of current character
-	int oldEols;      //!< the number of EOLs that appeared in a comment
-
-	void CreateHeapBlock();       //!< add a heap block, freeing unused ones
-	Token* CreateToken();         //!< fit token on the heap
-	void AppendVal(Token* tok);   //!< adjust tok->val to point to the heap and copy tval into it
-
-	void Init();      //!< complete the initialization for the constructors
-	void NextCh();    //!< get the next input character into ch
-	void AddCh();     //!< append the character ch to tval
-	bool Comment0();
-	bool Comment1();
-
-	Token* NextToken();  //!< get the next token
-
-public:
-	//! The scanner buffer
-	Buffer *buffer;
-
-	//! Using an existing open file handle for the scanner
-	Scanner(FILE*);
-
-	//! Using an existing open STL std stream
-	explicit Scanner(std::istream&);
-
-	//! Open a file for reading and attach scanner
-	explicit Scanner(const wchar_t* fileName);
-
-	//! Attach scanner to an existing character buffer
-	Scanner(const unsigned char* chars, int len);
-	//! Attach scanner to an existing character buffer
-	Scanner(const char* chars, int len);
-
-	~Scanner();        //!< free heap and allocated memory
-	Token* Scan();     //!< get the next token (possibly a token already seen during peeking)
-	Token* Peek();     //!< peek for the next token, ignore pragmas
-	void ResetPeek();  //!< ensure that peeking starts at the current scan position
-
-}; // end Scanner
-
-} // namespace
-} // namespace
-} // namespace
-
-
-#endif // COCO_calcEntrySCANNER_H__
-

applications/test/dictionary/testDictCalc

@@ -10,7 +10,7 @@ FoamFile
     version     2.0;
     format      ascii;
     class       dictionary;
-    object      testDictTest;
+    object      testDictCalc;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -19,28 +19,13 @@ flowRatePerHour 720;
 x       10;
 y       20;
 z       t s v;
-// z       #test{ // this
-//     123 - 456
-//         // comments // are
-//         /* stripped
-//         * 10
-//          * {}
-//          */
-//         + 1 /*100 */  10
-// };
+p       #calc{ 1 + 2 + 10 * 15 + $x - $y };
 
-p     this calculation #calc{
-          1 + 2 + 10 * 15 +
-          $x - $y
-        // $x + $y
-}
-is done inplace;
+// this calculation is in-place, but does not work inside a string:
+flowRate    "The flow rate " #calc{ $flowRatePerHour / 3600 } "kg/s";
 
+// this is also okay
+x   #calc{ $x * 1E-3 };
 
-flowRate    #calc{ $flowRatePerHour / 3600};
-
-xxx         yyy;
-foo         30;
-bar         15;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/test/dictionary/testDictCalcError

@@ -0,0 +1,46 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  Any                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      testDictCalcError;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+flowRatePerHour 720;
+
+x       10;
+y       20;
+z       t s v;
+// z       #test{ // this
+//     123 - 456
+//         // comments // are
+//         /* stripped
+//         * 10
+//          * {}
+//          */
+//         + 1 /*100 */  10
+// };
+
+p     this calculation #calc{
+          1xxx1 + 2 + 10 * 15 +
+          $x - $y
+        // $x + $y
+}
+is done inplace;
+
+
+flowRate    #calc{ $flowRatePerHour / 3600};
+
+xxx         yyy;
+foo         30;
+bar         15;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/mesh/advanced/modifyMesh/Make/options

@@ -1,9 +1,7 @@
 EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude
 
 EXE_LIBS = \
-    -ltriSurface \
     -lmeshTools \
     -ldynamicMesh

applications/utilities/mesh/advanced/splitCells/Make/options

@@ -1,9 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude
 
 EXE_LIBS = \
     -ldynamicMesh \
-    -ltriSurface \
     -lmeshTools

applications/utilities/mesh/conversion/foamToSurface/Make/files

@@ -0,0 +1,3 @@
+foamToSurface.C
+
+EXE = $(FOAM_APPBIN)/foamToSurface

applications/utilities/mesh/conversion/foamToSurface/Make/options

@@ -0,0 +1,5 @@
+EXE_INC = \
+    -I$(LIB_SRC)/surfMesh/lnInclude
+
+EXE_LIBS = \
+    -lsurfMesh

applications/utilities/mesh/conversion/foamToSurface/foamToSurface.C

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+    foamToSurface
+
+Description
+    Reads an OpenFOAM mesh and writes the boundaries in a surface format.
+
+Usage
+    - foamToSurface [OPTION] \n
+    Reads an OpenFOAM mesh and writes the boundaries in a surface format.
+
+    @param -scale \<factor\>\n
+    Specify an alternative geometry scaling factor.
+    Eg, use @b 1000 to scale @em [m] to @em [mm].
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "timeSelector.H"
+#include "Time.H"
+#include "polyMesh.H"
+
+#include "MeshedSurfaces.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::validArgs.append("outputFile.ext");
+    timeSelector::addOptions();
+
+    argList::addOption
+    (
+        "scale",
+        "scale",
+        "specify geometry scaling factor"
+    );
+
+#   include "setRootCase.H"
+
+    const stringList& params = args.additionalArgs();
+
+    scalar scaleFactor = 0;
+    args.optionReadIfPresent<scalar>("scale", scaleFactor);
+
+    fileName exportName(params[0]);
+
+    fileName exportBase = exportName.lessExt();
+    word exportExt = exportName.ext();
+
+    if (!meshedSurface::canWriteType(exportExt, true))
+    {
+        return 1;
+    }
+
+#   include "createTime.H"
+    instantList timeDirs = timeSelector::select0(runTime, args);
+#   include "createPolyMesh.H"
+
+    forAll(timeDirs, timeI)
+    {
+        runTime.setTime(timeDirs[timeI], timeI);
+#       include "getTimeIndex.H"
+
+        polyMesh::readUpdateState state = mesh.readUpdate();
+
+        if (timeI == 0 || state != polyMesh::UNCHANGED)
+        {
+            if (state == polyMesh::UNCHANGED)
+            {
+                exportName = exportBase + "." + exportExt;
+            }
+            else
+            {
+                exportName =
+                    exportBase + '_' + runTime.timeName() + "." + exportExt;
+            }
+
+            meshedSurface surf(mesh.boundaryMesh());
+            surf.scalePoints(scaleFactor);
+
+            Info<< "writing " << exportName;
+            if (scaleFactor <= 0)
+            {
+                Info<< " without scaling" << endl;
+            }
+            else
+            {
+                Info<< " with scaling " << scaleFactor << endl;
+            }
+            surf.write(exportName);
+        }
+
+        Info<< nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+// ************************************************************************* //

applications/utilities/mesh/conversion/foamToSurface/getTimeIndex.H

@@ -0,0 +1,51 @@
+// Read time index from */uniform/time, but treat 0 and constant specially
+
+    word timeName = "0";
+
+    if
+    (
+        runTime.timeName() != "constant"
+     && runTime.timeName() != "0"
+    )
+    {
+        IOobject io
+        (
+            "time",
+            runTime.timeName(),
+            "uniform",
+            runTime,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE,
+            false
+        );
+
+        if (io.headerOk())
+        {
+            IOdictionary timeObject
+            (
+                IOobject
+                (
+                    "time",
+                    runTime.timeName(),
+                    "uniform",
+                    runTime,
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            );
+
+            label index;
+            timeObject.lookup("index") >> index;
+            timeName = Foam::name(index);
+        }
+        else
+        {
+            timeName = runTime.timeName();
+            // Info<< "skip ... missing entry " << io.objectPath() << endl;
+            // continue;
+        }
+    }
+
+    Info<< "\nTime [" << timeName << "] = " << runTime.timeName() << nl;
+

applications/utilities/mesh/conversion/ideasUnvToFoam/Make/options

@@ -1,7 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/surfMesh/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \
-    -ltriSurface
+    -lsurfMesh

applications/utilities/mesh/conversion/ideasUnvToFoam/ideasUnvToFoam.C

@@ -41,7 +41,8 @@ Description
 #include "cellSet.H"
 #include "faceSet.H"
 #include "DynamicList.H"
-#include "triSurface.H"
+
+#include "MeshedSurfaces.H"
 
 using namespace Foam;
 
@@ -268,9 +269,11 @@ void readCells
             break;
         }
 
-        IStringStream lineStr(line);
         label cellI, feID, physProp, matProp, colour, nNodes;
-        lineStr >> cellI >> feID >> physProp >> matProp >> colour >> nNodes;
+
+        IStringStream lineStr(line);
+        lineStr
+            >> cellI >> feID >> physProp >> matProp >> colour >> nNodes;
 
         if (foundFeType.insert(feID))
         {
@@ -297,7 +300,8 @@ void readCells
 
             face cVerts(3);
             IStringStream lineStr(line);
-            lineStr >> cVerts[0] >> cVerts[1] >> cVerts[2];
+            lineStr
+                >> cVerts[0] >> cVerts[1] >> cVerts[2];
             boundaryFaces.append(cVerts);
             boundaryFaceIndices.append(cellI);
         }
@@ -308,7 +312,8 @@ void readCells
 
             face cVerts(4);
             IStringStream lineStr(line);
-            lineStr >> cVerts[0] >> cVerts[1] >> cVerts[2] >> cVerts[3];
+            lineStr
+                >> cVerts[0] >> cVerts[1] >> cVerts[2] >> cVerts[3];
             boundaryFaces.append(cVerts);
             boundaryFaceIndices.append(cellI);
         }
@@ -319,14 +324,15 @@ void readCells
 
             labelList cVerts(4);
             IStringStream lineStr(line);
-            lineStr >> cVerts[0] >> cVerts[1] >> cVerts[2] >> cVerts[3];
+            lineStr
+                >> cVerts[0] >> cVerts[1] >> cVerts[2] >> cVerts[3];
 
             cellVerts.append(cellShape(tet, cVerts, true));
             cellMaterial.append(physProp);
 
             if (cellVerts.last().size() != cVerts.size())
             {
-                Pout<< "Line:" << is.lineNumber()
+                Info<< "Line:" << is.lineNumber()
                     << " element:" << cellI
                     << " type:" << feID
                     << " collapsed from " << cVerts << nl
@@ -341,15 +347,16 @@ void readCells
 
             labelList cVerts(6);
             IStringStream lineStr(line);
-            lineStr >> cVerts[0] >> cVerts[1] >> cVerts[2] >> cVerts[3]
-                    >> cVerts[4] >> cVerts[5];
+            lineStr
+                >> cVerts[0] >> cVerts[1] >> cVerts[2]
+                >> cVerts[3] >> cVerts[4] >> cVerts[5];
 
             cellVerts.append(cellShape(prism, cVerts, true));
             cellMaterial.append(physProp);
 
             if (cellVerts.last().size() != cVerts.size())
             {
-                Pout<< "Line:" << is.lineNumber()
+                Info<< "Line:" << is.lineNumber()
                     << " element:" << cellI
                     << " type:" << feID
                     << " collapsed from " << cVerts << nl
@@ -373,7 +380,7 @@ void readCells
 
             if (cellVerts.last().size() != cVerts.size())
             {
-                Pout<< "Line:" << is.lineNumber()
+                Info<< "Line:" << is.lineNumber()
                     << " element:" << cellI
                     << " type:" << feID
                     << " collapsed from " << cVerts << nl
@@ -388,7 +395,7 @@ void readCells
                 IOWarningIn("readCells(IFstream&, label&)", is)
                     << "Cell type " << feID << " not supported" << endl;
             }
-            is.getLine(line);  //Do nothing
+            is.getLine(line);  // Do nothing
         }
     }
 
@@ -579,7 +586,11 @@ int main(int argc, char *argv[])
 {
     argList::noParallel();
     argList::validArgs.append(".unv file");
-    argList::addBoolOption("dump");
+    argList::addBoolOption
+    (
+        "dump",
+        "dump boundary faces as boundaryFaces.obj (for debugging)"
+    );
 
 #   include "setRootCase.H"
 #   include "createTime.H"
@@ -858,40 +869,25 @@ int main(int argc, char *argv[])
     polyPoints /= lengthScale;
 
 
-    // For debugging: dump boundary faces as triSurface
+    // For debugging: dump boundary faces as OBJ surface mesh
     if (args.optionFound("dump"))
     {
-        DynamicList<labelledTri> triangles(boundaryFaces.size());
-
-        forAll(boundaryFaces, i)
-        {
-            const face& f = boundaryFaces[i];
-
-            faceList triFaces(f.nTriangles(polyPoints));
-            label nTri = 0;
-            f.triangles(polyPoints, nTri, triFaces);
-
-            forAll(triFaces, triFaceI)
-            {
-                const face& f = triFaces[triFaceI];
-                triangles.append(labelledTri(f[0], f[1], f[2], 0));
-            }
-        }
-
-        // Create globally numbered tri surface
-        triSurface rawSurface(triangles.shrink(), polyPoints);
-
-        // Create locally numbered tri surface
-        triSurface surface
-        (
-            rawSurface.localFaces(),
-            rawSurface.localPoints()
-        );
-
-        Info<< "Writing boundary faces to STL file boundaryFaces.stl"
+        Info<< "Writing boundary faces to OBJ file boundaryFaces.obj"
             << nl << endl;
 
-        surface.write(runTime.path()/"boundaryFaces.stl");
+        // Create globally numbered surface
+        meshedSurface rawSurface
+        (
+            xferCopy(polyPoints),
+            xferCopyTo< faceList >(boundaryFaces)
+        );
+
+        // Write locally numbered surface
+        meshedSurface
+        (
+            xferCopy(rawSurface.localPoints()),
+            xferCopy(rawSurface.localFaces())
+        ).write(runTime.path()/"boundaryFaces.obj");
     }
 
 

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2010 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -56,11 +56,6 @@ scalar getMergeDistance(const polyMesh& mesh, const scalar mergeTol)
 {
     const boundBox& meshBb = mesh.bounds();
     scalar mergeDist = mergeTol * meshBb.mag();
-    scalar writeTol = std::pow
-    (
-        scalar(10.0),
-       -scalar(IOstream::defaultPrecision())
-    );
 
     Info<< nl
         << "Overall mesh bounding box  : " << meshBb << nl
@@ -68,17 +63,27 @@ scalar getMergeDistance(const polyMesh& mesh, const scalar mergeTol)
         << "Absolute matching distance : " << mergeDist << nl
         << endl;
 
-    if (mesh.time().writeFormat() == IOstream::ASCII && mergeTol < writeTol)
+    // check writing tolerance
+    if (mesh.time().writeFormat() == IOstream::ASCII)
     {
-        FatalErrorIn("getMergeDistance(const polyMesh&, const scalar)")
-            << "Your current settings specify ASCII writing with "
-            << IOstream::defaultPrecision() << " digits precision." << endl
-            << "Your merging tolerance (" << mergeTol << ") is finer than this."
-            << endl
-            << "Please change your writeFormat to binary"
-            << " or increase the writePrecision" << endl
-            << "or adjust the merge tolerance (-mergeTol)."
-            << exit(FatalError);
+        const scalar writeTol = std::pow
+        (
+            scalar(10.0),
+            -scalar(IOstream::defaultPrecision())
+        );
+
+        if (mergeTol < writeTol)
+        {
+            FatalErrorIn("getMergeDistance(const polyMesh&, const dictionary&)")
+                << "Your current settings specify ASCII writing with "
+                << IOstream::defaultPrecision() << " digits precision." << nl
+                << "Your merging tolerance (" << mergeTol
+                << ") is finer than this." << nl
+                << "Change to binary writeFormat, "
+                << "or increase the writePrecision" << endl
+                << "or adjust the merge tolerance (mergeTol)."
+                << exit(FatalError);
+        }
     }
 
     return mergeDist;
@@ -107,7 +112,7 @@ void writeMesh
             mesh.time().path()/meshRefiner.timeName()
         );
     }
-    Info<< "Written mesh in = "
+    Info<< "Wrote mesh in = "
         << mesh.time().cpuTimeIncrement() << " s." << endl;
 }
 
@@ -115,7 +120,11 @@ void writeMesh
 
 int main(int argc, char *argv[])
 {
-    argList::addBoolOption("overwrite");
+    argList::addBoolOption
+    (
+        "overwrite",
+        "overwrite existing mesh files"
+    );
 #   include "setRootCase.H"
 #   include "createTime.H"
     runTime.functionObjects().off();
@@ -126,7 +135,6 @@ int main(int argc, char *argv[])
 
     const bool overwrite = args.optionFound("overwrite");
 
-
     // Check patches and faceZones are synchronised
     mesh.boundaryMesh().checkParallelSync(true);
     meshRefinement::checkCoupledFaceZones(mesh);
@@ -173,7 +181,7 @@ int main(int argc, char *argv[])
     // layer addition parameters
     const dictionary& layerDict = meshDict.subDict("addLayersControls");
 
-
+    // absolute merge distance
     const scalar mergeDist = getMergeDistance
     (
         mesh,
@@ -181,17 +189,16 @@ int main(int argc, char *argv[])
     );
 
 
-
     // Debug
     // ~~~~~
 
-    const label debug(readLabel(meshDict.lookup("debug")));
+    const label debug = meshDict.lookupOrDefault<label>("debug", 0);
     if (debug > 0)
     {
-        meshRefinement::debug = debug;
+        meshRefinement::debug   = debug;
         autoRefineDriver::debug = debug;
-        autoSnapDriver::debug = debug;
-        autoLayerDriver::debug = debug;
+        autoSnapDriver::debug   = debug;
+        autoLayerDriver::debug  = debug;
     }
 
 
@@ -272,7 +279,7 @@ int main(int argc, char *argv[])
 
     meshRefiner.write
     (
-        debug&meshRefinement::OBJINTERSECTIONS,
+        debug & meshRefinement::OBJINTERSECTIONS,
         mesh.time().path()/meshRefiner.timeName()
     );
 
@@ -357,9 +364,9 @@ int main(int argc, char *argv[])
     // Now do the real work -refinement -snapping -layers
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    Switch wantRefine(meshDict.lookup("castellatedMesh"));
-    Switch wantSnap(meshDict.lookup("snap"));
-    Switch wantLayers(meshDict.lookup("addLayers"));
+    const Switch wantRefine(meshDict.lookup("castellatedMesh"));
+    const Switch wantSnap(meshDict.lookup("snap"));
+    const Switch wantLayers(meshDict.lookup("addLayers"));
 
     if (wantRefine)
     {
@@ -479,7 +486,7 @@ int main(int argc, char *argv[])
 
     Info<< "End\n" << endl;
 
-    return(0);
+    return 0;
 }
 
 

applications/utilities/mesh/manipulation/autoPatch/Make/options

@@ -1,10 +1,7 @@
 EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/lnInclude
 
-
 EXE_LIBS = \
-    -ltriSurface \
     -ldynamicMesh \
     -lmeshTools

applications/utilities/mesh/manipulation/objToVTK/Make/options

@@ -1,8 +1 @@
-/*
-EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude
-
-EXE_LIBS = \
-    -lmeshTools \
-    -ltriSurface
-*/
+/* */

applications/utilities/mesh/manipulation/refineMesh/Make/options

@@ -1,9 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude
 
-
 EXE_LIBS = \
     -ldynamicMesh \
     -lmeshTools

applications/utilities/miscellaneous/foamDebugSwitches/Make/options

@@ -18,6 +18,7 @@ EXE_LIBS = \
     -lengine \
     -lerrorEstimation \
     -lfieldFunctionObjects \
+    -lfileFormats \
     -lfiniteVolume \
     -lforces \
     -lfvMotionSolvers \

applications/utilities/postProcessing/sampling/probeLocations/Make/options

@@ -2,7 +2,6 @@ EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude
 
 EXE_LIBS = \
@@ -10,5 +9,4 @@ EXE_LIBS = \
     -lgenericPatchFields \
     -lmeshTools \
     -lsampling \
-    -ltriSurface \
     -llagrangian

applications/utilities/postProcessing/sampling/sample/Make/options

@@ -3,7 +3,6 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/surfMesh/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude \
     -I$(LIB_SRC)/lagrangian/basic/lnInclude
 
 EXE_LIBS = \
@@ -12,5 +11,4 @@ EXE_LIBS = \
     -lmeshTools \
     -lsampling \
     -lsurfMesh \
-    -ltriSurface \
     -llagrangian

applications/utilities/surface/surfaceAutoPatch/Make/options

@@ -1,5 +1,4 @@
 EXE_INC = \
-    /* -I$(LIB_SRC)/cfdTools/general/lnInclude */ \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/triSurface/lnInclude
 

applications/utilities/surface/surfaceFeatureConvert/Make/options

@@ -1,9 +1,7 @@
 EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/edgeMesh/lnInclude \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/edgeMesh/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \
-    -ledgeMesh \
-    -ltriSurface
+    -ledgeMesh

applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C

@@ -79,11 +79,7 @@ void deleteBox
     {
         const point eMid = surf.edges()[edgeI].centre(surf.localPoints());
 
-        if
-        (
-            (removeInside && bb.contains(eMid))
-         || (!removeInside && !bb.contains(eMid))
-        )
+        if (removeInside ? bb.contains(eMid) : !bb.contains(eMid))
         {
             edgeStat[edgeI] = surfaceFeatures::NONE;
         }
@@ -133,7 +129,6 @@ int main(int argc, char *argv[])
 
 
 
-
     // Either construct features from surface&featureangle or read set.
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

applications/utilities/surface/surfaceFind/Make/options

@@ -1,6 +1,6 @@
 EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/surfMesh/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \
-    -ltriSurface
+    -lsurfMesh

applications/utilities/surface/surfaceFind/surfaceFind.C

@@ -23,18 +23,16 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Description
-    Finds nearest triangle and vertex.
+    Finds nearest face and vertex.
 
 \*---------------------------------------------------------------------------*/
 
-#include "triSurface.H"
 #include "argList.H"
 #include "OFstream.H"
 
-#ifndef namespaceFoam
-#define namespaceFoam
-    using namespace Foam;
-#endif
+#include "MeshedSurfaces.H"
+
+using namespace Foam;
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -44,9 +42,9 @@ int main(int argc, char *argv[])
 {
     argList::noParallel();
     argList::validArgs.clear();
-    argList::addOption("x", "X");
-    argList::addOption("y", "Y");
-    argList::addOption("z", "Z");
+    argList::addOption("x", "X", "The point x-coordinate (if non-zero)");
+    argList::addOption("y", "Y", "The point y-coordinate (if non-zero)");
+    argList::addOption("z", "Z", "The point y-coordinate (if non-zero)");
 
     argList::validArgs.append("surface file");
 
@@ -54,15 +52,15 @@ int main(int argc, char *argv[])
 
     point samplePt
     (
-        args.optionRead<scalar>("x"),
-        args.optionRead<scalar>("y"),
-        args.optionRead<scalar>("z")
+        args.optionLookupOrDefault<scalar>("x", 0),
+        args.optionLookupOrDefault<scalar>("y", 0),
+        args.optionLookupOrDefault<scalar>("z", 0)
     );
     Info<< "Looking for nearest face/vertex to " << samplePt << endl;
 
 
-    Info<< "Reading surf1 ..." << endl;
-    triSurface surf1(args.additionalArgs()[0]);
+    Info<< "Reading surf ..." << endl;
+    meshedSurface surf1(args.additionalArgs()[0]);
 
     //
     // Nearest vertex
@@ -83,11 +81,11 @@ int main(int argc, char *argv[])
         }
     }
 
-    Info<< "Nearest vertex:" << endl
-        << "    index      :" << minIndex << " (in localPoints)" << endl
+    Info<< "Nearest vertex:" << nl
+        << "    index      :" << minIndex << " (in localPoints)" << nl
         << "    index      :" << surf1.meshPoints()[minIndex]
-        << " (in points)" << endl
-        << "    coordinates:" << localPoints[minIndex] << endl
+        << " (in points)" << nl
+        << "    coordinates:" << localPoints[minIndex] << nl
         << endl;
 
     //
@@ -101,8 +99,7 @@ int main(int argc, char *argv[])
 
     forAll(surf1, faceI)
     {
-        const labelledTri& f = surf1[faceI];
-        const point centre = f.centre(points);
+        const point centre = surf1[faceI].centre(points);
 
         const scalar dist = mag(centre - samplePt);
         if (dist < minDist)
@@ -112,16 +109,19 @@ int main(int argc, char *argv[])
         }
     }
 
-    const labelledTri& f = surf1[minIndex];
+    const face& f = surf1[minIndex];
 
-    Info<< "Face with nearest centre:" << endl
-        << "    index        :" << minIndex << endl
-        << "    centre       :" << f.centre(points) << endl
-        << "    face         :" << f << endl
-        << "    vertex coords:" << points[f[0]] << " "
-        << points[f[1]] << " " << points[f[2]] << endl
-        << endl;
+    Info<< "Face with nearest centre:" << nl
+        << "    index        :" << minIndex << nl
+        << "    centre       :" << f.centre(points) << nl
+        << "    face         :" << f << nl
+        << "    vertex coords:\n";
+    forAll(f, fp)
+    {
+        Info<< "        " << points[f[fp]] << "\n";
+    }
 
+    Info<< endl;
 
     Info<< "End\n" << endl;
 

applications/utilities/surface/surfaceSmooth/Make/options

@@ -1,6 +1,6 @@
 EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/surfMesh/lnInclude
 
 EXE_LIBS = \
     -lmeshTools \
-    -ltriSurface
+    -lsurfMesh

applications/utilities/surface/surfaceSmooth/surfaceSmooth.C

@@ -23,15 +23,16 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Description
-    Example of simple laplacian smoother
+    Example of a simple laplacian smoother
 
 \*---------------------------------------------------------------------------*/
 
-#include "triSurface.H"
 #include "argList.H"
 #include "OFstream.H"
 #include "boundBox.H"
 
+#include "MeshedSurfaces.H"
+
 using namespace Foam;
 
 
@@ -61,23 +62,20 @@ int main(int argc, char *argv[])
     label iters(readLabel(IStringStream(args.additionalArgs()[2])()));
     fileName outFileName(args.additionalArgs()[3]);
 
-    Info<< "Relax:" << relax << endl;
-    Info<< "Iters:" << iters << endl;
+    Info<< "Relax:" << relax << nl
+        << "Iters:" << iters << nl
+        << "Reading surface from " << surfFileName << " ..." << endl;
 
+    meshedSurface surf1(surfFileName);
 
-    Info<< "Reading surface from " << surfFileName << " ..." << endl;
-
-    triSurface surf1(surfFileName);
-
-    Info<< "Triangles    : " << surf1.size() << endl;
-    Info<< "Vertices     : " << surf1.nPoints() << endl;
-    Info<< "Bounding Box : " << boundBox(surf1.localPoints()) << endl;
+    Info<< "Faces        : " << surf1.size() << nl
+        << "Vertices     : " << surf1.nPoints() << nl
+        << "Bounding Box : " << boundBox(surf1.localPoints()) << endl;
 
     pointField newPoints(surf1.localPoints());
 
     const labelListList& pointEdges = surf1.pointEdges();
 
-
     for (label iter = 0; iter < iters; iter++)
     {
         forAll(pointEdges, vertI)
@@ -100,16 +98,14 @@ int main(int argc, char *argv[])
         }
     }
 
-    triSurface surf2
-    (
-        surf1.localFaces(),
-        surf1.patches(),
-        newPoints
-    );
-
     Info<< "Writing surface to " << outFileName << " ..." << endl;
 
-    surf2.write(outFileName);
+    meshedSurface
+    (
+        xferMove(newPoints),
+        xferCopy(surf1.localFaces()),
+        xferCopy(surf1.surfZones())
+    ).write(outFileName);
 
     Info<< "End\n" << endl;
 

applications/utilities/surface/surfaceSubset/surfaceSubset.C

@@ -100,10 +100,8 @@ int main(int argc, char *argv[])
         meshSubsetDict.lookup("addFaceNeighbours")
     );
 
-    Switch invertSelection
-    (
-        meshSubsetDict.lookup("invertSelection")
-    );
+    const bool invertSelection =
+        meshSubsetDict.lookupOrDefault<bool>("invertSelection", false);
 
     // Mark the cells for the subset
 
@@ -246,7 +244,7 @@ int main(int argc, char *argv[])
         // bb of surface
         treeBoundBox bb(selectSurf.localPoints());
 
-        // Radnom number generator
+        // Random number generator
         Random rndGen(354543);
 
         // search engine
@@ -269,14 +267,11 @@ int main(int argc, char *argv[])
                 indexedOctree<treeDataTriSurface>::volumeType t =
                     selectTree.getVolumeType(fc);
 
-                if (t == indexedOctree<treeDataTriSurface>::INSIDE && !outside)
-                {
-                    facesToSubset[faceI] = true;
-                }
-                else if
+                if
                 (
-                    t == indexedOctree<treeDataTriSurface>::OUTSIDE
-                 && outside
+                    outside
+                  ? (t == indexedOctree<treeDataTriSurface>::OUTSIDE)
+                  : (t == indexedOctree<treeDataTriSurface>::INSIDE)
                 )
                 {
                     facesToSubset[faceI] = true;
@@ -346,20 +341,11 @@ int main(int argc, char *argv[])
     if (invertSelection)
     {
         Info<< "Inverting selection." << endl;
-        boolList newFacesToSubset(facesToSubset.size());
 
         forAll(facesToSubset, i)
         {
-            if (facesToSubset[i])
-            {
-                newFacesToSubset[i] = false;
-            }
-            else
-            {
-                newFacesToSubset[i] = true;
-            }
+            facesToSubset[i] = facesToSubset[i] ? false : true;
         }
-        facesToSubset.transfer(newFacesToSubset);
     }
 
 

applications/utilities/surface/surfaceSubset/surfaceSubsetDict

@@ -36,7 +36,7 @@ zone
 surface
 {
     name "sphere.stl";
-    outside yes;
+    outside     yes;
 }
 
 // Extend selection with edge neighbours

applications/utilities/surface/surfaceTransformPoints/Make/options

@@ -1,6 +1,5 @@
 EXE_INC = \
-    -I$(LIB_SRC)/triSurface/lnInclude
+    -I$(LIB_SRC)/surfMesh/lnInclude
 
 EXE_LIBS = \
-    -lmeshTools \
-    -ltriSurface
+    -lsurfMesh

applications/utilities/surface/surfaceTransformPoints/surfaceTransformPoints.C

@@ -35,7 +35,6 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#include "triSurface.H"
 #include "argList.H"
 #include "OFstream.H"
 #include "IFstream.H"
@@ -45,6 +44,8 @@ Description
 #include "quaternion.H"
 #include "mathematicalConstants.H"
 
+#include "MeshedSurfaces.H"
+
 using namespace Foam;
 using namespace Foam::constant::mathematical;
 
@@ -114,7 +115,7 @@ int main(int argc, char *argv[])
             << exit(FatalError);
     }
 
-    triSurface surf1(surfFileName);
+    meshedSurface surf1(surfFileName);
 
     pointField points(surf1.points());
 
@@ -193,9 +194,8 @@ int main(int argc, char *argv[])
         points.replace(vector::Z, scaleVector.z()*points.component(vector::Z));
     }
 
-    triSurface surf2(surf1, surf1.patches(), points);
-
-    surf2.write(outFileName);
+    surf1.movePoints(points);
+    surf1.write(outFileName);
 
     Info<< "End\n" << endl;