Merge commit 'origin/master' into splitCyclic

Conflicts:
	applications/utilities/parallelProcessing/decomposePar/decomposePar.C
	applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
	applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H
	applications/utilities/parallelProcessing/decomposePar/domainDecompositionMesh.C
	src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.C
	src/OpenFOAM/fields/pointPatchFields/pointPatchField/pointPatchField.C
	src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.H
	src/OpenFOAM/meshes/polyMesh/globalMeshData/globalPoints.C
	src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
	src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
	src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C

TODO

@@ -18,6 +18,8 @@ OK - non-parallel finite volume : channelFoam
 OK - parallel finite volume with processorCyclic: channelFoam
     unitTestCases/channel395-splitCyclic vs. channel395-dev
 
+OK - preProcessing/foamUpgradeCyclics
+
 - amg
 - test createPatch pointSync
 - pointFields on cyclics. volPointInterpolation.
@@ -35,7 +37,6 @@ separation.
 - regionSplit
 - scotchDecomp
 - isoSurface.C
-- preProcessing/foamUpgradeCyclics
 - referredCellList.C
 - renumberMesh
 - work out scheduled communication?

applications/Allwmake

@@ -10,7 +10,7 @@ wmakeCheckPwd "$WM_PROJECT_DIR/applications" || {
 
 set -x
 
-wmake all solvers
 wmake all utilities
+wmake all solvers
 
 # ----------------------------------------------------------------- end-of-file

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)/meshTools/lnInclude
-    -I$(LIB_SRC)/triSurface/lnInclude
 
 EXE_LIBS = \
     -lengine \

applications/solvers/combustion/dieselEngineFoam/createFields.H

@@ -6,7 +6,7 @@ autoPtr<psiChemistryModel> pChemistry
 );
 psiChemistryModel& chemistry = pChemistry();
 
-hCombustionThermo& thermo = chemistry.thermo();
+hsCombustionThermo& thermo = chemistry.thermo();
 
 basicMultiComponentMixture& composition = thermo.composition();
 PtrList<volScalarField>& Y = composition.Y();
@@ -50,7 +50,7 @@ volVectorField U
 volScalarField& p = thermo.p();
 const volScalarField& psi = thermo.psi();
 const volScalarField& T = thermo.T();
-volScalarField& h = thermo.h();
+volScalarField& hs = thermo.hs();
 
 
 #include "compressibleCreatePhi.H"
@@ -92,4 +92,18 @@ forAll(Y, i)
 {
     fields.add(Y[i]);
 }
-fields.add(h);
+fields.add(hs);
+
+DimensionedField<scalar, volMesh> chemistrySh
+(
+    IOobject
+    (
+        "chemistry::Sh",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("chemistrySh", dimEnergy/dimTime/dimVolume, 0.0)
+);

applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Application
-    dieselFoam
+    dieselEngineFoam
 
 Description
     Solver for diesel engine spray and combustion.
@@ -103,13 +103,15 @@ int main(int argc, char *argv[])
             kappa = (runTime.deltaT() + tc)/(runTime.deltaT() + tc + tk);
         }
 
+        chemistrySh = kappa*chemistry.Sh()();
+
         #include "rhoEqn.H"
         #include "UEqn.H"
 
         for (label ocorr=1; ocorr <= nOuterCorr; ocorr++)
         {
             #include "YEqn.H"
-            #include "hEqn.H"
+            #include "hsEqn.H"
 
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)

applications/solvers/combustion/dieselEngineFoam/hEqn.H

@@ -1,13 +0,0 @@
-{
-    solve
-    (
-        fvm::ddt(rho, h)
-      + mvConvection->fvmDiv(phi, h)
-      - fvm::laplacian(turbulence->alphaEff(), h)
-     ==
-       DpDt
-     + dieselSpray.heatTransferSource()
-    );
-
-    thermo.correct();
-}

applications/solvers/combustion/dieselEngineFoam/hsEqn.H

@@ -0,0 +1,14 @@
+{
+    solve
+    (
+        fvm::ddt(rho, hs)
+      + mvConvection->fvmDiv(phi, hs)
+      - fvm::laplacian(turbulence->alphaEff(), hs)
+     ==
+       DpDt
+     + dieselSpray.heatTransferSource()().dimensionedInternalField()
+     + chemistrySh
+    );
+
+    thermo.correct();
+}

applications/solvers/combustion/dieselFoam/dieselFoam.C

@@ -100,7 +100,7 @@ int main(int argc, char *argv[])
         for (label ocorr=1; ocorr <= nOuterCorr; ocorr++)
         {
             #include "YEqn.H"
-            #include "hEqn.H"
+            #include "hsEqn.H"
 
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)

applications/solvers/combustion/fireFoam/Allwclean

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

applications/solvers/combustion/fireFoam/Allwmake

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+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,19 @@
+EXE_INC = \
+    -I./combustionModels/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 = \
+    -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

@@ -0,0 +1,113 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::noCombustion
+
+Description
+    No combustion
+
+SourceFiles
+    noCombustion.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef noCombustion_H
+#define noCombustion_H
+
+#include "combustionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace combustionModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class noCombustion Declaration
+\*---------------------------------------------------------------------------*/
+
+class noCombustion
+:
+    public combustionModel
+{
+    // Private data
+
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        noCombustion(const noCombustion&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const noCombustion&);
+
+
+public:
+
+    //- Runtime type information
+    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
+
+        //- 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/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/reactingFoam/Make/options

@@ -1,5 +1,4 @@
 EXE_INC = \
-    -I../XiFoam \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \

applications/solvers/combustion/reactingFoam/UEqn.H

@@ -0,0 +1,15 @@
+    fvVectorMatrix UEqn
+    (
+        fvm::ddt(rho, U)
+      + fvm::div(phi, U)
+      + turbulence->divDevRhoReff(U)
+     ==
+        rho*g
+    );
+
+    UEqn.relax();
+
+    if (momentumPredictor)
+    {
+        solve(UEqn == -fvc::grad(p));
+    }

applications/solvers/combustion/reactingFoam/chemistry.H

@@ -21,4 +21,6 @@
     {
         kappa = 1.0;
     }
+
+    chemistrySh = kappa*chemistry.Sh()();
 }

applications/solvers/combustion/reactingFoam/createFields.H

@@ -5,7 +5,7 @@ autoPtr<psiChemistryModel> pChemistry
 );
 psiChemistryModel& chemistry = pChemistry();
 
-hCombustionThermo& thermo = chemistry.thermo();
+hsCombustionThermo& thermo = chemistry.thermo();
 
 basicMultiComponentMixture& composition = thermo.composition();
 PtrList<volScalarField>& Y = composition.Y();
@@ -40,8 +40,8 @@ volVectorField U
 
 volScalarField& p = thermo.p();
 const volScalarField& psi = thermo.psi();
-volScalarField& h = thermo.h();
+volScalarField& hs = thermo.hs();
-
+const volScalarField& T = thermo.T();
 
 #include "compressibleCreatePhi.H"
 
@@ -81,5 +81,18 @@ forAll(Y, i)
 {
     fields.add(Y[i]);
 }
-fields.add(h);
+fields.add(hs);
 
+DimensionedField<scalar, volMesh> chemistrySh
+(
+    IOobject
+    (
+        "chemistry::Sh",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("chemistrySh", dimEnergy/dimTime/dimVolume, 0.0)
+);

applications/solvers/combustion/reactingFoam/hsEqn.H

@@ -0,0 +1,20 @@
+{
+    fvScalarMatrix hsEqn
+    (
+        fvm::ddt(rho, hs)
+      + mvConvection->fvmDiv(phi, hs)
+      - fvm::laplacian(turbulence->alphaEff(), hs)
+//      - fvm::laplacian(turbulence->muEff(), hs)  // unit lewis no.
+     ==
+        DpDt
+      + chemistrySh
+    );
+
+    hsEqn.relax();
+    hsEqn.solve();
+
+    thermo.correct();
+
+    Info<< "T gas min/max   = " << min(T).value() << ", "
+        << max(T).value() << endl;
+}

applications/solvers/combustion/reactingFoam/pEqn.H

@@ -0,0 +1,68 @@
+rho = thermo.rho();
+
+volScalarField rUA = 1.0/UEqn.A();
+U = rUA*UEqn.H();
+
+if (transonic)
+{
+    surfaceScalarField phid
+    (
+        "phid",
+        fvc::interpolate(psi)
+       *(
+            (fvc::interpolate(U) & mesh.Sf())
+          + fvc::ddtPhiCorr(rUA, rho, U, phi)
+        )
+    );
+
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvm::div(phid, p)
+          - fvm::laplacian(rho*rUA, p)
+        );
+
+        pEqn.solve();
+
+        if (nonOrth == nNonOrthCorr)
+        {
+            phi == pEqn.flux();
+        }
+    }
+}
+else
+{
+    phi =
+        fvc::interpolate(rho)
+       *(
+            (fvc::interpolate(U) & mesh.Sf())
+          + fvc::ddtPhiCorr(rUA, rho, U, phi)
+        );
+
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+    {
+        fvScalarMatrix pEqn
+        (
+            fvm::ddt(psi, p)
+          + fvc::div(phi)
+          - fvm::laplacian(rho*rUA, p)
+        );
+
+        pEqn.solve();
+
+        if (nonOrth == nNonOrthCorr)
+        {
+            phi += pEqn.flux();
+        }
+    }
+}
+
+#include "rhoEqn.H"
+#include "compressibleContinuityErrs.H"
+
+U -= rUA*fvc::grad(p);
+U.correctBoundaryConditions();
+
+DpDt = fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);

applications/solvers/combustion/reactingFoam/reactingFoam.C

@@ -73,9 +73,7 @@ int main(int argc, char *argv[])
         {
             #include "UEqn.H"
             #include "YEqn.H"
-
+            #include "hsEqn.H"
-            #define Db turbulence->alphaEff()
-            #include "hEqn.H"
 
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)

applications/solvers/combustion/rhoReactingFoam/Make/options

@@ -1,5 +1,4 @@
 EXE_INC = \
-    -I../XiFoam \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \

applications/solvers/combustion/rhoReactingFoam/UEqn.H

@@ -0,0 +1,15 @@
+    fvVectorMatrix UEqn
+    (
+        fvm::ddt(rho, U)
+      + fvm::div(phi, U)
+      + turbulence->divDevRhoReff(U)
+     ==
+        rho*g
+    );
+
+    UEqn.relax();
+
+    if (momentumPredictor)
+    {
+        solve(UEqn == -fvc::grad(p));
+    }

applications/solvers/combustion/rhoReactingFoam/chemistry.H

@@ -21,4 +21,6 @@
     {
         kappa = 1.0;
     }
+
+    chemistrySh = kappa*chemistry.Sh()();
 }

applications/solvers/combustion/rhoReactingFoam/createFields.H

@@ -5,7 +5,7 @@ autoPtr<rhoChemistryModel> pChemistry
 );
 rhoChemistryModel& chemistry = pChemistry();
 
-hReactionThermo& thermo = chemistry.thermo();
+hsReactionThermo& thermo = chemistry.thermo();
 
 basicMultiComponentMixture& composition = thermo.composition();
 PtrList<volScalarField>& Y = composition.Y();
@@ -40,7 +40,8 @@ volVectorField U
 
 volScalarField& p = thermo.p();
 const volScalarField& psi = thermo.psi();
-volScalarField& h = thermo.h();
+volScalarField& hs = thermo.hs();
+const volScalarField& T = thermo.T();
 
 
 #include "compressibleCreatePhi.H"
@@ -81,5 +82,18 @@ forAll(Y, i)
 {
     fields.add(Y[i]);
 }
-fields.add(h);
+fields.add(hs);
 
+DimensionedField<scalar, volMesh> chemistrySh
+(
+    IOobject
+    (
+        "chemistry::Sh",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh,
+    dimensionedScalar("chemistrySh", dimEnergy/dimTime/dimVolume, 0.0)
+);

applications/solvers/combustion/rhoReactingFoam/hsEqn.H

@@ -0,0 +1,19 @@
+{
+    fvScalarMatrix hsEqn
+    (
+        fvm::ddt(rho, hs)
+      + mvConvection->fvmDiv(phi, hs)
+      - fvm::laplacian(turbulence->alphaEff(), hs)
+     ==
+        DpDt
+      + chemistrySh
+    );
+
+    hsEqn.relax();
+    hsEqn.solve();
+
+    thermo.correct();
+
+    Info<< "T gas min/max   = " << min(T).value() << ", "
+        << max(T).value() << endl;
+}

applications/solvers/combustion/rhoReactingFoam/rhoReactingFoam.C

@@ -74,7 +74,7 @@ int main(int argc, char *argv[])
         {
             #include "UEqn.H"
             #include "YEqn.H"
-            #include "hEqn.H"
+            #include "hsEqn.H"
 
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)

applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files

@@ -1,6 +1,10 @@
+regionProperties/regionProperties.C
+
 derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C
+derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C
 
 fluid/compressibleCourantNo.C
+solid/solidRegionDiffNo.C
 
 chtMultiRegionFoam.C
 

applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options

@@ -2,11 +2,11 @@ EXE_INC = \
     -Ifluid \
     -Isolid \
     -IregionProperties \
+    -Iinclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel
-    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude
 
 EXE_LIBS = \
     -lbasicThermophysicalModels \

applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C

@@ -37,6 +37,7 @@ Description
 #include "fixedGradientFvPatchFields.H"
 #include "regionProperties.H"
 #include "compressibleCourantNo.H"
+#include "solidRegionDiffNo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -56,23 +57,24 @@ int main(int argc, char *argv[])
     #include "initContinuityErrs.H"
 
     #include "readTimeControls.H"
+    #include "readSolidTimeControls.H"
+
+
+    #include "compressibleMultiRegionCourantNo.H"
+    #include "solidRegionDiffusionNo.H"
+    #include "setInitialMultiRegionDeltaT.H"
 
-    if (fluidRegions.size())
-    {
-        #include "compressibleMultiRegionCourantNo.H"
-        #include "setInitialDeltaT.H"
-    }
 
     while (runTime.run())
     {
         #include "readTimeControls.H"
+        #include "readSolidTimeControls.H"
         #include "readPIMPLEControls.H"
 
-        if (fluidRegions.size())
+
-        {
+        #include "compressibleMultiRegionCourantNo.H"
-            #include "compressibleMultiRegionCourantNo.H"
+        #include "solidRegionDiffusionNo.H"
-            #include "setDeltaT.H"
+        #include "setMultiRegionDeltaT.H"
-        }
 
         runTime++;
 
@@ -117,7 +119,7 @@ int main(int argc, char *argv[])
             << nl << endl;
     }
 
-    Info<< "End\n" << endl;
+    Info << "End\n" << endl;
 
     return 0;
 }

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C

@@ -0,0 +1,382 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "solidWallMixedTemperatureCoupledFvPatchScalarField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvPatchFieldMapper.H"
+#include "volFields.H"
+#include "directMappedPatchBase.H"
+#include "regionProperties.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::interfaceOwner
+(
+    const polyMesh& nbrRegion
+) const
+{
+    const fvMesh& myRegion = patch().boundaryMesh().mesh();
+
+    const regionProperties& props =
+        myRegion.objectRegistry::parent().lookupObject<regionProperties>
+        (
+            "regionProperties"
+        );
+
+    label myIndex = findIndex(props.fluidRegionNames(), myRegion.name());
+    if (myIndex == -1)
+    {
+        label i = findIndex(props.solidRegionNames(), myRegion.name());
+
+        if (i == -1)
+        {
+            FatalErrorIn
+            (
+                "solidWallMixedTemperatureCoupledFvPatchScalarField"
+                "::interfaceOwner(const polyMesh&) const"
+            )   << "Cannot find region " << myRegion.name()
+                << " neither in fluids " << props.fluidRegionNames()
+                << " nor in solids " << props.solidRegionNames()
+                << exit(FatalError);
+        }
+        myIndex = props.fluidRegionNames().size() + i;
+    }
+    label nbrIndex = findIndex(props.fluidRegionNames(), nbrRegion.name());
+    if (nbrIndex == -1)
+    {
+        label i = findIndex(props.solidRegionNames(), nbrRegion.name());
+
+        if (i == -1)
+        {
+            FatalErrorIn("coupleManager::interfaceOwner(const polyMesh&) const")
+                << "Cannot find region " << nbrRegion.name()
+                << " neither in fluids " << props.fluidRegionNames()
+                << " nor in solids " << props.solidRegionNames()
+                << exit(FatalError);
+        }
+        nbrIndex = props.fluidRegionNames().size() + i;
+    }
+
+    return myIndex < nbrIndex;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF
+)
+:
+    mixedFvPatchScalarField(p, iF),
+    neighbourFieldName_("undefined-neighbourFieldName"),
+    KName_("undefined-K")
+{
+    this->refValue() = 0.0;
+    this->refGrad() = 0.0;
+    this->valueFraction() = 1.0;
+    this->fixesValue_ = true;
+}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const solidWallMixedTemperatureCoupledFvPatchScalarField& ptf,
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mixedFvPatchScalarField(ptf, p, iF, mapper),
+    neighbourFieldName_(ptf.neighbourFieldName_),
+    KName_(ptf.KName_),
+    fixesValue_(ptf.fixesValue_)
+{}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const fvPatch& p,
+    const DimensionedField<scalar, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mixedFvPatchScalarField(p, iF),
+    neighbourFieldName_(dict.lookup("neighbourFieldName")),
+    KName_(dict.lookup("K"))
+{
+    if (!isA<directMappedPatchBase>(this->patch().patch()))
+    {
+        FatalErrorIn
+        (
+            "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            "solidWallMixedTemperatureCoupledFvPatchScalarField\n"
+            "(\n"
+            "    const fvPatch& p,\n"
+            "    const DimensionedField<scalar, volMesh>& iF,\n"
+            "    const dictionary& dict\n"
+            ")\n"
+        )   << "\n    patch type '" << p.type()
+            << "' not type '" << directMappedPatchBase::typeName << "'"
+            << "\n    for patch " << p.name()
+            << " of field " << dimensionedInternalField().name()
+            << " in file " << dimensionedInternalField().objectPath()
+            << exit(FatalError);
+    }
+
+    fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
+
+    if (dict.found("refValue"))
+    {
+        // Full restart
+        refValue() = scalarField("refValue", dict, p.size());
+        refGrad() = scalarField("refGradient", dict, p.size());
+        valueFraction() = scalarField("valueFraction", dict, p.size());
+        fixesValue_ = readBool(dict.lookup("fixesValue"));
+    }
+    else
+    {
+        // Start from user entered data. Assume fixedValue.
+        refValue() = *this;
+        refGrad() = 0.0;
+        valueFraction() = 1.0;
+        fixesValue_ = true;
+    }
+}
+
+
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
+solidWallMixedTemperatureCoupledFvPatchScalarField
+(
+    const solidWallMixedTemperatureCoupledFvPatchScalarField& wtcsf,
+    const DimensionedField<scalar, volMesh>& iF
+)
+:
+    mixedFvPatchScalarField(wtcsf, iF),
+    neighbourFieldName_(wtcsf.neighbourFieldName_),
+    KName_(wtcsf.KName_),
+    fixesValue_(wtcsf.fixesValue_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::fvPatchScalarField&
+Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::K() const
+{
+    return this->patch().lookupPatchField<volScalarField, scalar>(KName_);
+}
+
+
+void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::updateCoeffs()
+{
+    if (updated())
+    {
+        return;
+    }
+
+    // Get the coupling information from the directMappedPatchBase
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        patch().patch()
+    );
+    const polyMesh& nbrMesh = mpp.sampleMesh();
+    // Force recalculation of mapping and schedule
+    const mapDistribute& distMap = mpp.map();
+    (void)distMap.schedule();
+
+    tmp<scalarField> intFld = patchInternalField();
+
+    if (interfaceOwner(nbrMesh))
+    {
+        // Note: other side information could be cached - it only needs
+        // to be updated the first time round the iteration (i.e. when
+        // switching regions) but unfortunately we don't have this information.
+
+        const fvPatch& nbrPatch = refCast<const fvMesh>
+        (
+            nbrMesh
+        ).boundary()[mpp.samplePolyPatch().index()];
+
+
+        // Calculate the temperature by harmonic averaging
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        const solidWallMixedTemperatureCoupledFvPatchScalarField& nbrField =
+        refCast<const solidWallMixedTemperatureCoupledFvPatchScalarField>
+        (
+            nbrPatch.lookupPatchField<volScalarField, scalar>
+            (
+                neighbourFieldName_
+            )
+        );
+
+        // Swap to obtain full local values of neighbour internal field
+        scalarField nbrIntFld = nbrField.patchInternalField();
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            distMap.constructSize(),
+            distMap.subMap(),           // what to send
+            distMap.constructMap(),     // what to receive
+            nbrIntFld
+        );
+
+        // Swap to obtain full local values of neighbour K*delta
+        scalarField nbrKDelta = nbrField.K()*nbrPatch.deltaCoeffs();
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            distMap.constructSize(),
+            distMap.subMap(),           // what to send
+            distMap.constructMap(),     // what to receive
+            nbrKDelta
+        );
+
+
+        tmp<scalarField> myKDelta = K()*patch().deltaCoeffs();
+
+        // Calculate common wall temperature. Reuse *this to store common value.
+        scalarField Twall
+        (
+            (myKDelta()*intFld() + nbrKDelta*nbrIntFld)
+          / (myKDelta() + nbrKDelta)
+        );
+        // Assign to me
+        fvPatchScalarField::operator=(Twall);
+        // Distribute back and assign to neighbour
+        mapDistribute::distribute
+        (
+            Pstream::defaultCommsType,
+            distMap.schedule(),
+            nbrField.size(),
+            distMap.constructMap(),     // reverse : what to send
+            distMap.subMap(),
+            Twall
+        );
+        const_cast<solidWallMixedTemperatureCoupledFvPatchScalarField&>
+        (
+            nbrField
+        ).fvPatchScalarField::operator=(Twall);
+    }
+
+
+    // Switch between fixed value (of harmonic avg) or gradient
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    label nFixed = 0;
+
+    // Like snGrad but bypass switching on refValue/refGrad.
+    tmp<scalarField> normalGradient = (*this-intFld())*patch().deltaCoeffs();
+
+    if (debug)
+    {
+        scalar Q = gSum(K()*patch().magSf()*normalGradient());
+
+        Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            << "updateCoeffs() :"
+            << " patch:" << patch().name()
+            << " heatFlux:" << Q
+            << " walltemperature "
+            << " min:" << gMin(*this)
+            << " max:" << gMax(*this)
+            << " avg:" << gAverage(*this)
+            << endl;
+    }
+
+    forAll(*this, i)
+    {
+        // if outgoing flux use fixed value.
+        if (normalGradient()[i] < 0.0)
+        {
+            this->refValue()[i] = operator[](i);
+            this->refGrad()[i] = 0.0;   // not used by me
+            this->valueFraction()[i] = 1.0;
+            nFixed++;
+        }
+        else
+        {
+            // Fixed gradient. Make sure to have valid refValue (even though
+            // I am not using it - other boundary conditions might)
+            this->refValue()[i] = operator[](i);
+            this->refGrad()[i] = normalGradient()[i];
+            this->valueFraction()[i] = 0.0;
+        }
+    }
+
+    reduce(nFixed, sumOp<label>());
+
+    fixesValue_ = (nFixed > 0);
+
+    if (debug)
+    {
+        label nTotSize = returnReduce(this->size(), sumOp<label>());
+
+        Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
+            << "updateCoeffs() :"
+            << " patch:" << patch().name()
+            << " out of:" << nTotSize
+            << " fixedBC:" << nFixed
+            << " gradient:" << nTotSize-nFixed << endl;
+    }
+
+    mixedFvPatchScalarField::updateCoeffs();
+}
+
+
+void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::write
+(
+    Ostream& os
+) const
+{
+    mixedFvPatchScalarField::write(os);
+    os.writeKeyword("neighbourFieldName")<< neighbourFieldName_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("K") << KName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("fixesValue") << fixesValue_ << token::END_STATEMENT << nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+makePatchTypeField
+(
+    fvPatchScalarField,
+    solidWallMixedTemperatureCoupledFvPatchScalarField
+);
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.H

@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    solidWallMixedTemperatureCoupledFvPatchScalarField
+
+Description
+    Mixed boundary condition for temperature, to be used by the
+    conjugate heat transfer solver.
+    If my temperature is T1, neighbour is T2:
+
+    T1 > T2: my side becomes fixedValue T2 bc, other side becomes fixedGradient.
+    
+
+    Example usage:
+        myInterfacePatchName
+        {
+            type                solidWallMixedTemperatureCoupled;
+            neighbourFieldName  T;
+            K                   K;
+            value               uniform 300;
+        }
+
+    Needs to be on underlying directMapped(Wall)FvPatch.
+
+    Note: runs in parallel with arbitrary decomposition. Uses directMapped
+    functionality to calculate exchange.
+
+    Note: lags interface data so both sides use same data.
+    - problem: schedule to calculate average would interfere
+    with standard processor swaps.
+    - so: updateCoeffs sets both to same Twall. Only need to do
+    this for last outer iteration but don't have access to this.
+
+SourceFiles
+    solidWallMixedTemperatureCoupledFvPatchScalarField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef solidWallMixedTemperatureCoupledFvPatchScalarField_H
+#define solidWallMixedTemperatureCoupledFvPatchScalarField_H
+
+#include "fvPatchFields.H"
+#include "mixedFvPatchFields.H"
+#include "fvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+        Class solidWallMixedTemperatureCoupledFvPatchScalarField Declaration
+\*---------------------------------------------------------------------------*/
+
+class solidWallMixedTemperatureCoupledFvPatchScalarField
+:
+    public mixedFvPatchScalarField
+{
+    // Private data
+
+        //- Name of field on the neighbour region
+        const word neighbourFieldName_;
+        
+        //- Name of thermal conductivity field
+        const word KName_;
+
+        bool fixesValue_;
+
+
+    // Private Member Functions
+
+        //- Am I or neighbour owner of interface
+        bool interfaceOwner(const polyMesh& nbrRegion) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("solidWallMixedTemperatureCoupled");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        //  solidWallMixedTemperatureCoupledFvPatchScalarField onto a new patch
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const solidWallMixedTemperatureCoupledFvPatchScalarField&,
+            const fvPatch&,
+            const DimensionedField<scalar, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchScalarField> clone() const
+        {
+            return tmp<fvPatchScalarField>
+            (
+                new solidWallMixedTemperatureCoupledFvPatchScalarField(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        solidWallMixedTemperatureCoupledFvPatchScalarField
+        (
+            const solidWallMixedTemperatureCoupledFvPatchScalarField&,
+            const DimensionedField<scalar, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchScalarField> clone
+        (
+            const DimensionedField<scalar, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchScalarField>
+            (
+                new solidWallMixedTemperatureCoupledFvPatchScalarField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        //- Get corresponding K field
+        const fvPatchScalarField& K() const;
+
+        //- Return true if this patch field fixes a value.
+        //  Needed to check if a level has to be specified while solving
+        //  Poissons equations.
+        virtual bool fixesValue() const
+        {
+            return fixesValue_;
+        }
+
+        //- Update the coefficients associated with the patch field
+        virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleCourantNo.C

@@ -47,10 +47,10 @@ Foam::scalar Foam::compressibleCourantNo
           / fvc::interpolate(rho);
 
         CoNum = max(SfUfbyDelta/mesh.magSf())
-            .value()*runTime.deltaTValue();
+            .value()*runTime.deltaT().value();
 
         meanCoNum = (sum(SfUfbyDelta)/sum(mesh.magSf()))
-            .value()*runTime.deltaTValue();
+            .value()*runTime.deltaT().value();
     }
 
     Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H

@@ -1,15 +1,18 @@
     scalar CoNum = -GREAT;
-    forAll(fluidRegions, regionI)
+    if (fluidRegions.size())
     {
-        CoNum = max
+        forAll(fluidRegions, regionI)
-        (
+        {
-            compressibleCourantNo
+            CoNum = max
             (
-                fluidRegions[regionI],
+                compressibleCourantNo
-                runTime,
+                (
-                rhoFluid[regionI],
+                    fluidRegions[regionI],
-                phiFluid[regionI]
+                    runTime,
-            ),
+                    rhoFluid[regionI],
-            CoNum
+                    phiFluid[regionI]
-        );
+                ),
+                CoNum
+            );
+        }
     }

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H

@@ -41,6 +41,24 @@
             )
         );
 
+        Info<< "    Adding to KFluid\n" << endl;
+        KFluid.set
+        (
+            i,
+            new volScalarField
+            (
+                IOobject
+                (
+                    "K",
+                    runTime.timeName(),
+                    fluidRegions[i],
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                thermoFluid[i].Cp()*thermoFluid[i].alpha()
+            )
+        );
+
         Info<< "    Adding to UFluid\n" << endl;
         UFluid.set
         (
@@ -111,24 +129,6 @@
             ).ptr()
         );
 
-        Info<< "    Adding to KFluid\n" << endl;
-        KFluid.set
-        (
-            i,
-            new volScalarField
-            (
-                IOobject
-                (
-                    "K",
-                    runTime.timeName(),
-                    fluidRegions[i],
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                thermoFluid[i].Cp()*turbulence[i].alphaEff()
-            )
-        );
-
         Info<< "    Adding to DpDtFluid\n" << endl;
         DpDtFluid.set
         (

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setInitialMultiRegionDeltaT.H

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Global
+    setInitialDeltaT
+
+Description
+    Set the initial timestep for the CHT MultiRegion solver.
+
+\*---------------------------------------------------------------------------*/
+
+if (adjustTimeStep)
+{
+    if ((runTime.timeIndex() == 0) && ((CoNum > SMALL) || (DiNum > SMALL)))
+    {
+
+        if (CoNum == -GREAT)
+        {
+            CoNum = SMALL;
+        }
+
+        if (DiNum == -GREAT)
+        {
+            DiNum = SMALL;
+        }
+
+        runTime.setDeltaT
+        (
+            min
+            (
+                min(maxCo/CoNum, maxDi/DiNum)*runTime.deltaT().value(),
+                maxDeltaT
+            )
+        );
+        Info<< "deltaT = " <<  runTime.deltaT().value() << endl;
+    }
+}
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/include/setMultiRegionDeltaT.H

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Global
+    setMultiRegionDeltaT
+
+Description
+    Reset the timestep to maintain a constant maximum courant and diffusion
+    Numbers. Reduction of time-step is immediate, but increase is damped to avoid
+    unstable oscillations.
+
+\*---------------------------------------------------------------------------*/
+
+if (adjustTimeStep)
+{
+    if (CoNum == -GREAT)
+    {
+        CoNum = SMALL;
+    }
+
+    if (DiNum == -GREAT)
+    {
+        DiNum = SMALL;
+    }
+
+    scalar maxDeltaTFluid = maxCo/(CoNum + SMALL);
+    scalar maxDeltaTSolid = maxDi/(DiNum + SMALL);
+
+    scalar deltaTFluid =
+        min
+        (
+            min(maxDeltaTFluid, 1.0 + 0.1*maxDeltaTFluid),
+            1.2
+        );
+
+    runTime.setDeltaT
+    (
+        min
+        (
+            min(deltaTFluid, maxDeltaTSolid)*runTime.deltaT().value(),
+            maxDeltaT
+        )
+    );
+
+    Info<< "deltaT = " <<  runTime.deltaT().value() << endl;
+}
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.C

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "regionProperties.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::regionProperties::regionProperties(const Time& runTime)
+:
+    IOdictionary
+    (
+        IOobject
+        (
+            "regionProperties",
+            runTime.time().constant(),
+            runTime.db(),
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    ),
+    fluidRegionNames_(lookup("fluidRegionNames")),
+    solidRegionNames_(lookup("solidRegionNames"))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::regionProperties::~regionProperties()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::List<Foam::word>& Foam::regionProperties::fluidRegionNames() const
+{
+    return fluidRegionNames_;
+}
+
+
+const Foam::List<Foam::word>& Foam::regionProperties::solidRegionNames() const
+{
+    return solidRegionNames_;
+}
+
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.H

@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    regionProperties
+
+Description
+    Simple class to hold region information for coupled region simulations
+
+SourceFiles
+    regionProperties.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef regionProperties_H
+#define regionProperties_H
+
+#include "IOdictionary.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class regionProperties Declaration
+\*---------------------------------------------------------------------------*/
+
+class regionProperties
+:
+    public IOdictionary
+{
+    // Private data
+
+        //- List of the fluid region names
+        List<word> fluidRegionNames_;
+
+        //- List of the solid region names
+        List<word> solidRegionNames_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        regionProperties(const regionProperties&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const regionProperties&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        regionProperties(const Time& runTime);
+
+
+    // Destructor
+
+        ~regionProperties();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return const reference to the list of fluid region names
+            const List<word>& fluidRegionNames() const;
+
+            //- Return const reference to the list of solid region names
+            const List<word>& solidRegionNames() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/readSolidTimeControls.H

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Global
+    readSolidTimeControls
+
+Description
+    Read the control parameters used in the solid
+
+\*---------------------------------------------------------------------------*/
+
+scalar maxDi = runTime.controlDict().lookupOrDefault<scalar>("maxDi", 10.0);
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.C

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+\*---------------------------------------------------------------------------*/
+
+#include "solidRegionDiffNo.H"
+#include "fvc.H"
+
+Foam::scalar Foam::solidRegionDiffNo
+(
+    const fvMesh& mesh,
+    const Time& runTime,
+    const volScalarField& Cprho,
+    const volScalarField& K
+)
+{
+    scalar DiNum = 0.0;
+    scalar meanDiNum = 0.0;
+
+    //- Can have fluid domains with 0 cells so do not test.
+    if (mesh.nInternalFaces())
+    {
+        surfaceScalarField KrhoCpbyDelta =
+            mesh.surfaceInterpolation::deltaCoeffs()
+          * fvc::interpolate(K)
+          / fvc::interpolate(Cprho);
+
+        DiNum = max(KrhoCpbyDelta.internalField())*runTime.deltaT().value();
+
+        meanDiNum = (average(KrhoCpbyDelta)).value()*runTime.deltaT().value();
+    }
+
+    Info<< "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum
+        << " max: " << DiNum << endl;
+
+    return DiNum;
+}
+
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+
+Description
+    Calculates and outputs the mean and maximum Diffusion Numbers for the solid
+    regions
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef solidRegionDiff_H
+#define solidRegionDiff_H
+
+#include "fvMesh.H"
+
+namespace Foam
+{
+    scalar solidRegionDiffNo
+    (
+        const fvMesh& mesh,
+        const Time& runTime,
+        const volScalarField& Cprho,
+        const volScalarField& K
+    );
+}
+
+#endif
+
+// ************************************************************************* //

applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffusionNo.H

@@ -0,0 +1,18 @@
+    scalar DiNum = -GREAT;
+    if (solidRegions.size())
+    {
+        forAll(solidRegions, regionI)
+        {
+            DiNum = max
+            (
+                solidRegionDiffNo
+                (
+                    solidRegions[regionI],
+                    runTime,
+                    rhosCps[regionI],
+                    Ks[regionI]
+                ),
+                DiNum
+            );
+        }
+    }

applications/solvers/heatTransfer/chtMultiRegionSimpleFoam/chtMultiRegionSimpleFoam.C

@@ -55,7 +55,7 @@ int main(int argc, char *argv[])
     #include "initContinuityErrs.H"
 
 
-    while (runTime.run())
+    while (runTime.loop())
     {
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
@@ -81,8 +81,6 @@ int main(int argc, char *argv[])
             #include "convergenceCheck.H"
         }
 
-        runTime++;
-
         runTime.write();
 
         Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"

applications/solvers/incompressible/boundaryFoam/interrogateWallPatches.H

@@ -11,7 +11,7 @@ forAll(patches, patchi)
 {
     const fvPatch& currPatch = patches[patchi];
 
-    if (isType<wallFvPatch>(currPatch))
+    if (isA<wallFvPatch>(currPatch))
     {
         const vectorField nf = currPatch.nf();
 

applications/solvers/incompressible/simpleFoam/pEqn.H

@@ -40,4 +40,3 @@
     // Momentum corrector
     U -= fvc::grad(p)/AU;
     U.correctBoundaryConditions();
-

applications/solvers/lagrangian/coalChemistryFoam/chemistry.H

@@ -22,4 +22,6 @@
     {
         kappa = 1.0;
     }
+
+    chemistrySh = kappa*chemistry.Sh()();
 }

applications/solvers/lagrangian/coalChemistryFoam/coalChemistryFoam.C

@@ -26,8 +26,13 @@ Application
     coalChemistryFoam
 
 Description
-    Transient solver for compressible, turbulent flow with coal and
+    Transient solver for:
-    limestone parcel injections, and combustion.
+    - 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"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -79,16 +84,8 @@ int main(int argc, char *argv[])
 
         coalParcels.evolve();
 
-        coalParcels.info();
-
-        Info<< endl;
-
         limestoneParcels.evolve();
 
-        limestoneParcels.info();
-
-        Info<< endl;
-
         #include "chemistry.H"
         #include "rhoEqn.H"
 
@@ -97,16 +94,13 @@ int main(int argc, char *argv[])
         {
             #include "UEqn.H"
             #include "YEqn.H"
-            #include "hEqn.H"
+            #include "hsEqn.H"
 
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)
             {
                 #include "pEqn.H"
             }
-
-            Info<< "T gas min/max   = " << min(T).value() << ", "
-                << max(T).value() << endl;
         }
 
         turbulence->correct();

applications/solvers/lagrangian/coalChemistryFoam/createFields.H

@@ -6,7 +6,7 @@
     );
     psiChemistryModel& chemistry = pChemistry();
 
-    hCombustionThermo& thermo = chemistry.thermo();
+    hsCombustionThermo& thermo = chemistry.thermo();
 
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
@@ -22,7 +22,7 @@
     }
 
     volScalarField& p = thermo.p();
-    volScalarField& h = thermo.h();
+    volScalarField& hs = thermo.hs();
     const volScalarField& T = thermo.T();
     const volScalarField& psi = thermo.psi();
 
@@ -32,7 +32,7 @@
     {
         fields.add(Y[i]);
     }
-    fields.add(h);
+    fields.add(hs);
 
     volScalarField rho
     (
@@ -127,10 +127,25 @@
         fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p)
     );
 
-    Info<< "\nConstructing explicit enthalpy cell source" << endl;
+    Info<< "\nConstructing explicit enthalpy source" << endl;
-    timeActivatedExplicitCellSource enthalpySource
+    scalarTimeActivatedExplicitSourceList enthalpySource
     (
-        "enthalpySource",
+        "energy",
         mesh,
-        h.dimensions()*phi.dimensions()/mesh.V().dimensions()
+        dimEnergy/dimTime/dimVolume,
+        "hs"
+    );
+
+    DimensionedField<scalar, volMesh> chemistrySh
+    (
+        IOobject
+        (
+            "chemistry::Sh",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("chemistrySh", dimEnergy/dimTime/dimVolume, 0.0)
     );

applications/solvers/lagrangian/coalChemistryFoam/hEqn.H

@@ -1,22 +0,0 @@
-{
-    fvScalarMatrix hEqn
-    (
-        fvm::ddt(rho, h)
-      + mvConvection->fvmDiv(phi, h)
-      - fvm::laplacian(turbulence->alphaEff(), h)
-     ==
-        DpDt
-     +  coalParcels.Sh()
-     +  limestoneParcels.Sh()
-     +  enthalpySource.Su()
-     +  radiation->Sh(thermo)
-    );
-
-    hEqn.relax();
-
-    hEqn.solve();
-
-    thermo.correct();
-
-    radiation->correct();
-}

applications/solvers/lagrangian/coalChemistryFoam/hsEqn.H

@@ -0,0 +1,26 @@
+{
+    fvScalarMatrix hsEqn
+    (
+        fvm::ddt(rho, hs)
+      + mvConvection->fvmDiv(phi, hs)
+      - fvm::laplacian(turbulence->alphaEff(), hs)
+     ==
+        DpDt
+     +  coalParcels.Sh()
+     +  limestoneParcels.Sh()
+     +  enthalpySource.Su()
+     +  radiation->Shs(thermo)
+     +  chemistrySh
+    );
+
+    hsEqn.relax();
+
+    hsEqn.solve();
+
+    thermo.correct();
+
+    radiation->correct();
+
+    Info<< "T gas min/max   = " << min(T).value() << ", "
+        << max(T).value() << endl;
+}

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/chemistry.H

@@ -22,4 +22,6 @@
     {
         kappa = 1.0;
     }
+
+    chemistrySh = kappa*chemistry.Sh()();
 }

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/createFields.H

@@ -6,7 +6,7 @@
     );
     rhoChemistryModel& chemistry = pChemistry();
 
-    hReactionThermo& thermo = chemistry.thermo();
+    hsReactionThermo& thermo = chemistry.thermo();
 
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
@@ -22,7 +22,7 @@
     }
 
     volScalarField& p = thermo.p();
-    volScalarField& h = thermo.h();
+    volScalarField& hs = thermo.hs();
     const volScalarField& T = thermo.T();
     const volScalarField& psi = thermo.psi();
 
@@ -88,4 +88,18 @@
     {
         fields.add(Y[i]);
     }
-    fields.add(h);
+    fields.add(hs);
+
+    DimensionedField<scalar, volMesh> chemistrySh
+    (
+        IOobject
+        (
+            "chemistry::Sh",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("chemistrySh", dimEnergy/dimTime/dimVolume, 0.0)
+    );

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/hsEqn.H

@@ -32,13 +32,15 @@
     {
         solve
         (
-            fvm::ddt(rho, h)
+            fvm::ddt(rho, hs)
-          + mvConvection->fvmDiv(phi, h)
+          + mvConvection->fvmDiv(phi, hs)
-          - fvm::laplacian(turbulence->alphaEff(), h)
+          - fvm::laplacian(turbulence->alphaEff(), hs)
          ==
             pWork()
           + parcels.Sh()
-          + radiation->Sh(thermo)
+          + radiation->Shs(thermo)
+          + energySource.Su()
+          + chemistrySh
         );
 
         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,12 +27,13 @@ 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
+    - mass, momentum and energy sources
     - polynomial based, incompressible thermodynamics (f(T))
 
     Note: ddtPhiCorr not used here when porous zones are active
@@ -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"
@@ -88,13 +89,11 @@ int main(int argc, char *argv[])
 
         parcels.evolve();
 
-        parcels.info();
-
         #include "chemistry.H"
         #include "rhoEqn.H"
         #include "UEqn.H"
         #include "YEqn.H"
-        #include "hEqn.H"
+        #include "hsEqn.H"
 
         // --- PISO loop
         for (int corr=0; corr<nCorr; corr++)

applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/rhoEqn.H

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

applications/solvers/lagrangian/reactingParcelFoam/chemistry.H

@@ -22,4 +22,6 @@
     {
         kappa = 1.0;
     }
+
+    chemistrySh = kappa*chemistry.Sh()();
 }

applications/solvers/lagrangian/reactingParcelFoam/createFields.H

@@ -6,7 +6,7 @@
     );
     psiChemistryModel& chemistry = pChemistry();
 
-    hCombustionThermo& thermo = chemistry.thermo();
+    hsCombustionThermo& thermo = chemistry.thermo();
 
     basicMultiComponentMixture& composition = thermo.composition();
     PtrList<volScalarField>& Y = composition.Y();
@@ -22,7 +22,7 @@
     }
 
     volScalarField& p = thermo.p();
-    volScalarField& h = thermo.h();
+    volScalarField& hs = thermo.hs();
     const volScalarField& T = thermo.T();
     const volScalarField& psi = thermo.psi();
 
@@ -94,4 +94,18 @@
     {
         fields.add(Y[i]);
     }
-    fields.add(h);
+    fields.add(hs);
+
+    DimensionedField<scalar, volMesh> chemistrySh
+    (
+        IOobject
+        (
+            "chemistry::Sh",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("chemistry::Sh", dimEnergy/dimTime/dimVolume, 0.0)
+    );

applications/solvers/lagrangian/reactingParcelFoam/hEqn.H

@@ -1,20 +0,0 @@
-{
-    fvScalarMatrix hEqn
-    (
-        fvm::ddt(rho, h)
-      + mvConvection->fvmDiv(phi, h)
-      - fvm::laplacian(turbulence->alphaEff(), h)
-     ==
-        DpDt
-     +  parcels.Sh()
-     +  radiation->Sh(thermo)
-    );
-
-    hEqn.relax();
-
-    hEqn.solve();
-
-    thermo.correct();
-
-    radiation->correct();
-}

applications/solvers/lagrangian/reactingParcelFoam/hsEqn.H

@@ -0,0 +1,24 @@
+{
+    fvScalarMatrix hEqn
+    (
+        fvm::ddt(rho, hs)
+      + mvConvection->fvmDiv(phi, hs)
+      - fvm::laplacian(turbulence->alphaEff(), hs)
+     ==
+        DpDt
+     +  parcels.Sh()
+     +  radiation->Shs(thermo)
+     +  chemistrySh
+    );
+
+    hEqn.relax();
+
+    hEqn.solve();
+
+    thermo.correct();
+
+    radiation->correct();
+
+    Info<< "T gas min/max   = " << min(T).value() << ", "
+        << max(T).value() << endl;
+}

applications/solvers/lagrangian/reactingParcelFoam/reactingParcelFoam.C

@@ -74,8 +74,6 @@ int main(int argc, char *argv[])
 
         parcels.evolve();
 
-        parcels.info();
-
         #include "chemistry.H"
         #include "rhoEqn.H"
 
@@ -88,12 +86,9 @@ int main(int argc, char *argv[])
             // --- PISO loop
             for (int corr=1; corr<=nCorr; corr++)
             {
-                #include "hEqn.H"
+                #include "hsEqn.H"
                 #include "pEqn.H"
             }
-
-            Info<< "T gas min/max   = " << min(T).value() << ", "
-                << max(T).value() << endl;
         }
 
         turbulence->correct();

applications/solvers/lagrangian/uncoupledKinematicParcelFoam/uncoupledKinematicParcelFoam.C

@@ -61,7 +61,6 @@ int main(int argc, char *argv[])
 
         Info<< "Evolving " << kinematicCloud.name() << endl;
         kinematicCloud.evolve();
-        kinematicCloud.info();
 
         runTime.write();
 

applications/solvers/multiphase/settlingFoam/UEqn.H

@@ -22,8 +22,7 @@
           ==
             fvc::reconstruct
             (
-                fvc::interpolate(rho)*(g & mesh.Sf())
+                (- ghf*fvc::snGrad(rho) - fvc::snGrad(pmh))*mesh.magSf()
-              - fvc::snGrad(p)*mesh.magSf()
             )
         );
     }

applications/solvers/multiphase/settlingFoam/createFields.H

@@ -1,9 +1,9 @@
-    Info<< "Reading field p\n" << endl;
+    Info<< "Reading field pmh\n" << endl;
-    volScalarField p
+    volScalarField pmh
     (
         IOobject
         (
-            "p",
+            "pmh",
             runTime.timeName(),
             mesh,
             IOobject::MUST_READ,
@@ -119,11 +119,6 @@
     #include "compressibleCreatePhi.H"
 
 
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell(p, mesh.solutionDict().subDict("PISO"), pRefCell, pRefValue);
-
-
     Info<< "Calculating field mul\n" << endl;
     volScalarField mul
     (
@@ -346,3 +341,48 @@
         ),
         mut + mul
     );
+
+
+    Info<< "Calculating field (g.h)f\n" << endl;
+    volScalarField gh("gh", g & mesh.C());
+    surfaceScalarField ghf = surfaceScalarField("gh", g & mesh.Cf());
+
+    volScalarField p
+    (
+        IOobject
+        (
+            "p",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pmh + rho*gh
+    );
+
+    label pmhRefCell = 0;
+    scalar pmhRefValue = 0.0;
+    setRefCell
+    (
+        pmh,
+        mesh.solutionDict().subDict("PISO"),
+        pmhRefCell,
+        pmhRefValue
+    );
+
+    scalar pRefValue = 0.0;
+
+    if (pmh.needReference())
+    {
+        pRefValue = readScalar
+        (
+            mesh.solutionDict().subDict("PISO").lookup("pRefValue")
+        );
+
+        p += dimensionedScalar
+        (
+            "p",
+            p.dimensions(),
+            pRefValue - getRefCellValue(p, pmhRefCell)
+        );
+    }

applications/solvers/multiphase/settlingFoam/pmhEqn.H

@@ -0,0 +1,52 @@
+volScalarField rUA = 1.0/UEqn.A();
+
+surfaceScalarField rUAf
+(
+    "(rho*(1|A(U)))",
+    fvc::interpolate(rho)*fvc::interpolate(rUA)
+);
+
+U = rUA*UEqn.H();
+phi =
+    fvc::interpolate(rho)
+   *(
+       (fvc::interpolate(U) & mesh.Sf())
+     + fvc::ddtPhiCorr(rUA, rho, U, phi)
+    );
+
+surfaceScalarField phiU("phiU", phi);
+phi -= ghf*fvc::snGrad(rho)*rUAf*mesh.magSf();
+
+for(int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
+{
+    fvScalarMatrix pmhEqn
+    (
+        fvm::laplacian(rUAf, pmh) == fvc::ddt(rho) + fvc::div(phi)
+    );
+
+    pmhEqn.setReference(pmhRefCell, pmhRefValue);
+    pmhEqn.solve();
+
+    if (nonOrth == nNonOrthCorr)
+    {
+        phi -= pmhEqn.flux();
+    }
+}
+
+p == pmh + rho*gh;
+
+if (pmh.needReference())
+{
+    p += dimensionedScalar
+    (
+        "p",
+        p.dimensions(),
+        pRefValue - getRefCellValue(p, pmhRefCell)
+    );
+}
+
+#include "rhoEqn.H"
+#include "compressibleContinuityErrs.H"
+
+U += rUA*fvc::reconstruct((phi - phiU)/rUAf);
+U.correctBoundaryConditions();

applications/solvers/multiphase/settlingFoam/settlingFoam.C

@@ -64,22 +64,24 @@ int main(int argc, char *argv[])
 
         #include "rhoEqn.H"
 
-        #include "calcVdj.H"
+        for (int oCorr=0; oCorr<nOuterCorr; oCorr++)
-
-        #include "UEqn.H"
-
-        #include "alphaEqn.H"
-
-        #include "correctViscosity.H"
-
-
-        // --- PISO loop
-        for (int corr=0; corr<nCorr; corr++)
         {
-            #include "pEqn.H"
+            #include "calcVdj.H"
-        }
 
-        #include "kEpsilon.H"
+            #include "UEqn.H"
+
+            #include "alphaEqn.H"
+
+            #include "correctViscosity.H"
+
+            // --- PISO loop
+            for (int corr=0; corr<nCorr; corr++)
+            {
+                #include "pmhEqn.H"
+            }
+
+            #include "kEpsilon.H"
+        }
 
         runTime.write();
 

applications/test/List/ListTest.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
@@ -90,7 +90,7 @@ int main(int argc, char *argv[])
 
     if (args.optionFound("flag"))
     {
-        Info<<"-flag:" << args.option("flag") << endl;
+        Info<<"-flag:" << args["flag"] << endl;
     }
 
     if (args.optionReadIfPresent<scalar>("float", xxx))

applications/test/ODETest/ODETest.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
@@ -109,10 +109,8 @@ int main(int argc, char *argv[])
     argList::validArgs.append("ODESolver");
     argList args(argc, argv);
 
-    word ODESolverName(args.additionalArgs()[0]);
-
     testODE ode;
-    autoPtr<ODESolver> odeSolver = ODESolver::New(ODESolverName, ode);
+    autoPtr<ODESolver> odeSolver = ODESolver::New(args[1], ode);
 
     scalar xStart = 1.0;
     scalarField yStart(ode.nEqns());

applications/test/PackedList/PackedListTest.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
@@ -130,15 +130,15 @@ int main(int argc, char *argv[])
 
         return 0;
     }
-    else if (args.additionalArgs().empty())
+    else if (args.size() <= 1)
     {
         args.printUsage();
     }
 
 
-    forAll(args.additionalArgs(), argI)
+    for (label argI=1; argI < args.size(); ++argI)
     {
-        const string& srcFile = args.additionalArgs()[argI];
+        const string& srcFile = args[argI];
         Info<< nl << "reading " << srcFile << nl;
 
         IFstream ifs(srcFile);

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.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/dictionaryTest.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
@@ -51,7 +51,7 @@ int main(int argc, char *argv[])
         << "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << nl
         << endl;
 
-    if (args.additionalArgs().empty())
+    if (args.size() <= 1)
     {
         {
             dictionary dict1(IFstream("testDict")());
@@ -114,9 +114,9 @@ int main(int argc, char *argv[])
     else
     {
         IOobject::writeDivider(Info);
-        forAll(args.additionalArgs(), argI)
+        for (label argI=1; argI < args.size(); ++argI)
         {
-            const string& dictFile = args.additionalArgs()[argI];
+            const string& dictFile = args[argI];
             IFstream is(dictFile);
 
             dictionary dict(is);

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
+p       #calc{ 1 + 2 + 10 * 15 + $x - $y };
-//     123 - 456
-//         // comments // are
-//         /* stripped
-//         * 10
-//          * {}
-//          */
-//         + 1 /*100 */  10
-// };
 
-p     this calculation #calc{
+// this calculation is in-place, but does not work inside a string:
-          1 + 2 + 10 * 15 +
+flowRate    "The flow rate " #calc{ $flowRatePerHour / 3600 } "kg/s";
-          $x - $y
-        // $x + $y
-}
-is done inplace;
 
+// 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/test/fileName/fileNameTest.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
@@ -69,7 +69,7 @@ int main()
         word name;
 
         fileName path(SubList<word>(wrdList, wrdList.size()-start, start));
-        fileName path2 = "." / path;
+        fileName path2 = "."/path;
 
         IOobject::fileNameComponents
         (