Merge branch 'master' of ssh://noisy/home/noisy3/OpenFOAM/OpenFOAM-dev

src/OpenFOAM/Make/files

@@ -341,13 +341,14 @@ $(basicPolyPatches)/coupled/coupledPolyPatch.C
 $(basicPolyPatches)/generic/genericPolyPatch.C
 
 constraintPolyPatches = $(polyPatches)/constraint
-$(constraintPolyPatches)/empty/emptyPolyPatch.C
-$(constraintPolyPatches)/symmetry/symmetryPolyPatch.C
-$(constraintPolyPatches)/wedge/wedgePolyPatch.C
 $(constraintPolyPatches)/cyclic/cyclicPolyPatch.C
 $(constraintPolyPatches)/cyclicSlip/cyclicSlipPolyPatch.C
+$(constraintPolyPatches)/empty/emptyPolyPatch.C
+$(constraintPolyPatches)/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.C
 $(constraintPolyPatches)/processorCyclic/processorCyclicPolyPatch.C
 $(constraintPolyPatches)/processor/processorPolyPatch.C
+$(constraintPolyPatches)/symmetry/symmetryPolyPatch.C
+$(constraintPolyPatches)/wedge/wedgePolyPatch.C
 
 derivedPolyPatches = $(polyPatches)/derived
 $(derivedPolyPatches)/wall/wallPolyPatch.C
@@ -453,13 +454,14 @@ $(basicPointPatches)/coupled/coupledPointPatch.C
 $(basicPointPatches)/generic/genericPointPatch.C
 
 constraintPointPatches = $(pointPatches)/constraint
-$(constraintPointPatches)/empty/emptyPointPatch.C
-$(constraintPointPatches)/symmetry/symmetryPointPatch.C
-$(constraintPointPatches)/wedge/wedgePointPatch.C
 $(constraintPointPatches)/cyclic/cyclicPointPatch.C
 $(constraintPointPatches)/cyclicSlip/cyclicSlipPointPatch.C
+$(constraintPointPatches)/empty/emptyPointPatch.C
+$(constraintPointPatches)/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatch.C
 $(constraintPointPatches)/processor/processorPointPatch.C
 $(constraintPointPatches)/processorCyclic/processorCyclicPointPatch.C
+$(constraintPointPatches)/symmetry/symmetryPointPatch.C
+$(constraintPointPatches)/wedge/wedgePointPatch.C
 
 derivedPointPatches = $(pointPatches)/derived
 $(derivedPointPatches)/coupled/coupledFacePointPatch.C
@@ -520,13 +522,14 @@ $(basicPointPatchFields)/zeroGradient/zeroGradientPointPatchFields.C
 $(basicPointPatchFields)/mixed/mixedPointPatchFields.C
 
 constraintPointPatchFields = $(pointPatchFields)/constraint
-$(constraintPointPatchFields)/empty/emptyPointPatchFields.C
-$(constraintPointPatchFields)/symmetry/symmetryPointPatchFields.C
-$(constraintPointPatchFields)/wedge/wedgePointPatchFields.C
 $(constraintPointPatchFields)/cyclic/cyclicPointPatchFields.C
 $(constraintPointPatchFields)/cyclicSlip/cyclicSlipPointPatchFields.C
+$(constraintPointPatchFields)/empty/emptyPointPatchFields.C
+$(constraintPointPatchFields)/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchFields.C
 $(constraintPointPatchFields)/processor/processorPointPatchFields.C
 $(constraintPointPatchFields)/processorCyclic/processorCyclicPointPatchFields.C
+$(constraintPointPatchFields)/symmetry/symmetryPointPatchFields.C
+$(constraintPointPatchFields)/wedge/wedgePointPatchFields.C
 
 derivedPointPatchFields = $(pointPatchFields)/derived
 $(derivedPointPatchFields)/slip/slipPointPatchFields.C

src/OpenFOAM/db/Time/Time.C

@@ -804,7 +804,11 @@ Foam::Time& Foam::Time::operator++()
 
             case wcCpuTime:
             {
-                label outputIndex = label(elapsedCpuTime()/writeInterval_);
+                label outputIndex = label
+                (
+                    returnReduce(elapsedCpuTime(), maxOp<double>())
+                  / writeInterval_
+                );
                 if (outputIndex > outputTimeIndex_)
                 {
                     outputTime_ = true;
@@ -819,7 +823,11 @@ Foam::Time& Foam::Time::operator++()
 
             case wcClockTime:
             {
-                label outputIndex = label(elapsedClockTime()/writeInterval_);
+                label outputIndex = label
+                (
+                    returnReduce(label(elapsedClockTime()), maxOp<label>())
+                  / writeInterval_
+                );
                 if (outputIndex > outputTimeIndex_)
                 {
                     outputTime_ = true;

src/OpenFOAM/db/dictionary/dictionary.H

@@ -38,8 +38,7 @@ Description
     dictionaries since, unlike the IOdictionary class, it does not use an
     objectRegistry itself to work.
 
-ToDo
-    A merge() member function with a non-const dictionary parameter.
+    To add - a merge() member function with a non-const dictionary parameter?
     This would avoid unnecessary cloning in the add(entry*, bool) method.
 
 SourceFiles

src/OpenFOAM/fields/pointPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchField.C

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicPointPatchField.H"
+#include "transformField.H"
+#include "symmTransformField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+nonuniformTransformCyclicPointPatchField<Type>::
+nonuniformTransformCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    cyclicPointPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicPointPatchField<Type>::
+nonuniformTransformCyclicPointPatchField
+(
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicPointPatchField<Type>(p, iF, dict)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicPointPatchField<Type>::
+nonuniformTransformCyclicPointPatchField
+(
+    const nonuniformTransformCyclicPointPatchField<Type>& ptf,
+    const pointPatch& p,
+    const DimensionedField<Type, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    cyclicPointPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicPointPatchField<Type>::
+nonuniformTransformCyclicPointPatchField
+(
+    const nonuniformTransformCyclicPointPatchField<Type>& ptf,
+    const DimensionedField<Type, pointMesh>& iF
+)
+:
+    cyclicPointPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void nonuniformTransformCyclicPointPatchField<Type>::evaluate
+(
+    const Pstream::commsTypes
+)
+{
+    const vectorField& nHat = this->patch().pointNormals();
+
+    tmp<Field<Type> > tvalues =
+    (
+        (
+            this->patchInternalField()
+          + transform(I - 2.0*sqr(nHat), this->patchInternalField())
+        )/2.0
+    );
+
+    // Get internal field to insert values into
+    Field<Type>& iF = const_cast<Field<Type>&>(this->internalField());
+
+    setInInternalField(iF, tvalues());
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchField.H

@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicPointPatchField
+
+Description
+    Cyclic + slip constraints
+
+SourceFiles
+    nonuniformTransformCyclicPointPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicPointPatchField_H
+#define nonuniformTransformCyclicPointPatchField_H
+
+#include "cyclicPointPatchField.H"
+#include "nonuniformTransformCyclicPointPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class nonuniformTransformCyclicPointPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonuniformTransformCyclicPointPatchField
+:
+    public cyclicPointPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonuniformTransformCyclicPointPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonuniformTransformCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonuniformTransformCyclicPointPatchField
+        (
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<Type> onto a new patch
+        nonuniformTransformCyclicPointPatchField
+        (
+            const nonuniformTransformCyclicPointPatchField<Type>&,
+            const pointPatch&,
+            const DimensionedField<Type, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<Type> > clone() const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new nonuniformTransformCyclicPointPatchField<Type>
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        nonuniformTransformCyclicPointPatchField
+        (
+            const nonuniformTransformCyclicPointPatchField<Type>&,
+            const DimensionedField<Type, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<Type> > clone
+        (
+            const DimensionedField<Type, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<Type> >
+            (
+                new nonuniformTransformCyclicPointPatchField<Type>
+                (
+                    *this, iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Evaluate the patch field
+            virtual void evaluate
+            (
+                const Pstream::commsTypes commsType=Pstream::blocking
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#    include "nonuniformTransformCyclicPointPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicPointPatchFields.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePointPatchFields(nonuniformTransformCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatchFields.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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicPointPatchFields_H
+#define nonuniformTransformCyclicPointPatchFields_H
+
+#include "nonuniformTransformCyclicPointPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchFieldTypedefs(nonuniformTransformCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatch.C

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicPointPatch.H"
+#include "pointConstraint.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(nonuniformTransformCyclicPointPatch, 0);
+
+// Add the patch constructor functions to the hash tables
+addToRunTimeSelectionTable
+(
+    facePointPatch,
+    nonuniformTransformCyclicPointPatch,
+    polyPatch
+);
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const vectorField& nonuniformTransformCyclicPointPatch::pointNormals() const
+{
+    // Use underlying patch normals
+    return refCast<const facePointPatch>
+    (
+        *this
+    ).facePointPatch::pointNormals();
+}
+
+
+void nonuniformTransformCyclicPointPatch::applyConstraint
+(
+    const label pointi,
+    pointConstraint& pc
+) const
+{
+    pc.applyConstraint(pointNormals()[pointi]);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPointPatch.H

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicPointPatch
+
+Description
+    Cyclic patch with slip constraint
+
+SourceFiles
+    nonuniformTransformCyclicPointPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicPointPatch_H
+#define nonuniformTransformCyclicPointPatch_H
+
+#include "cyclicPointPatch.H"
+#include "nonuniformTransformCyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class nonuniformTransformCyclicPointPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonuniformTransformCyclicPointPatch
+:
+    public cyclicPointPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonuniformTransformCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        nonuniformTransformCyclicPointPatch
+        (
+            const polyPatch& patch,
+            const pointBoundaryMesh& bm
+        )
+        :
+            cyclicPointPatch(patch, bm)
+        {}
+
+
+    // Destructor
+
+        virtual ~nonuniformTransformCyclicPointPatch()
+        {}
+
+
+    // Member Functions
+
+        //- Return point unit normals.
+        virtual const vectorField& pointNormals() const;
+
+        //- Accumulate the effect of constraint direction of this patch
+        virtual void applyConstraint
+        (
+            const label pointi,
+            pointConstraint&
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.C

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonuniformTransformCyclicPolyPatch, 0);
+
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        nonuniformTransformCyclicPolyPatch,
+        word
+    );
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        nonuniformTransformCyclicPolyPatch,
+        dictionary
+    );
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicPolyPatch.H

@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicPolyPatch
+
+Description
+    Transform boundary used in extruded regions. Allows non-uniform transforms.
+    Wip.
+
+SourceFiles
+    nonuniformTransformCyclicPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicPolyPatch_H
+#define nonuniformTransformCyclicPolyPatch_H
+
+#include "cyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class nonuniformTransformCyclicPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonuniformTransformCyclicPolyPatch
+:
+    public cyclicPolyPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("nonuniformTransformCyclic");
+
+
+    // Constructors
+
+        //- Construct from components
+        nonuniformTransformCyclicPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        )
+        :
+            cyclicPolyPatch(name, size, start, index, bm)
+        {}
+
+        //- Construct from dictionary
+        nonuniformTransformCyclicPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        )
+        :
+            cyclicPolyPatch(name, dict, index, bm)
+        {}
+
+        //- Construct as copy, resetting the boundary mesh
+        nonuniformTransformCyclicPolyPatch
+        (
+            const nonuniformTransformCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm
+        )
+        :
+            cyclicPolyPatch(pp, bm)
+        {}
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        nonuniformTransformCyclicPolyPatch
+        (
+            const nonuniformTransformCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart,
+            const word& neighbPatchName
+        )
+        :
+            cyclicPolyPatch(pp, bm, index, newSize, newStart, neighbPatchName)
+        {}
+
+        //- Construct given the original patch and a map
+        nonuniformTransformCyclicPolyPatch
+        (
+            const nonuniformTransformCyclicPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const unallocLabelList& mapAddressing,
+            const label newStart
+        )
+        :
+            cyclicPolyPatch(pp, bm, index, mapAddressing, newStart)
+        {}
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonuniformTransformCyclicPolyPatch(*this, bm)
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonuniformTransformCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart,
+                    neighbPatchName()
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const unallocLabelList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new nonuniformTransformCyclicPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    // Destructor
+
+        virtual ~nonuniformTransformCyclicPolyPatch()
+        {}
+
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C

@@ -27,6 +27,7 @@ License
 #include "entry.H"
 #include "demandDrivenData.H"
 #include "stringListOps.H"
+#include "Pstream.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -372,6 +373,84 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::checkDefinition
 }
 
 
+template<class ZoneType, class MeshType>
+bool Foam::ZoneMesh<ZoneType, MeshType>::checkParallelSync
+(
+    const bool report
+) const
+{
+    if (!Pstream::parRun())
+    {
+        return false;
+    }
+
+
+    const PtrList<ZoneType>& zones = *this;
+
+    bool hasError = false;
+
+    // Collect all names
+    List<wordList> allNames(Pstream::nProcs());
+    allNames[Pstream::myProcNo()] = this->names();
+    Pstream::gatherList(allNames);
+    Pstream::scatterList(allNames);
+
+    List<wordList> allTypes(Pstream::nProcs());
+    allTypes[Pstream::myProcNo()] = this->types();
+    Pstream::gatherList(allTypes);
+    Pstream::scatterList(allTypes);
+
+    // Have every processor check but only master print error.
+
+    for (label procI = 1; procI < allNames.size(); procI++)
+    {
+        if
+        (
+            (allNames[procI] != allNames[0])
+         || (allTypes[procI] != allTypes[0])
+        )
+        {
+            hasError = true;
+
+            if (debug || (report && Pstream::master()))
+            {
+                Info<< " ***Inconsistent zones across processors, "
+                       "processor 0 has zone names:" << allNames[0]
+                    << " zone types:" << allTypes[0]
+                    << " processor " << procI << " has zone names:"
+                    << allNames[procI]
+                    << " zone types:" << allTypes[procI]
+                    << endl;
+            }
+        }
+    }
+
+    // Check contents
+    if (!hasError)
+    {
+        forAll(zones, zoneI)
+        {
+            if (zones[zoneI].checkParallelSync(false))
+            {
+                hasError = true;
+
+                if (debug || (report && Pstream::master()))
+                {
+                    Info<< " ***Zone " << zones[zoneI].name()
+                        << " of type " << zones[zoneI].type()
+                        << " is not correctly synchronised"
+                        << " across coupled boundaries."
+                        << " (coupled faces are either not both "
+                        << " present in set or have same flipmap)" << endl;
+                }
+            }
+        }
+    }
+
+    return hasError;
+}
+
+
 // Correct zone mesh after moving points
 template<class ZoneType, class MeshType>
 void Foam::ZoneMesh<ZoneType, MeshType>::movePoints(const pointField& p)

src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.H

@@ -149,6 +149,10 @@ public:
         //- Check zone definition. Return true if in error.
         bool checkDefinition(const bool report = false) const;
 
+        //- Check whether all procs have all zones and in same order. Return
+        //  true if in error.
+        bool checkParallelSync(const bool report = false) const;
+
         //- Correct zone mesh after moving points
         void movePoints(const pointField&);
 

src/OpenFOAM/meshes/polyMesh/zones/cellZone/cellZone.H

@@ -209,6 +209,13 @@ public:
         //- Check zone definition. Return true if in error.
         virtual bool checkDefinition(const bool report = false) const;
 
+        //- Check whether zone is synchronised across coupled boundaries. Return
+        //  true if in error.
+        virtual bool checkParallelSync(const bool report = false) const
+        {
+            return false;
+        }
+
         //- Write dictionary
         virtual void writeDict(Ostream&) const;
 

src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZone.C

@@ -29,6 +29,7 @@ License
 #include "polyMesh.H"
 #include "primitiveMesh.H"
 #include "demandDrivenData.H"
+#include "syncTools.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -134,6 +135,49 @@ bool Foam::pointZone::checkDefinition(const bool report) const
 }
 
 
+bool Foam::pointZone::checkParallelSync(const bool report) const
+{
+    const polyMesh& mesh = zoneMesh().mesh();
+
+    labelList maxZone(mesh.nPoints(), -1);
+    labelList minZone(mesh.nPoints(), labelMax);
+    forAll(*this, i)
+    {
+        label pointI = operator[](i);
+        maxZone[pointI] = index();
+        minZone[pointI] = index();
+    }
+    syncTools::syncPointList(mesh, maxZone, maxEqOp<label>(), -1);
+    syncTools::syncPointList(mesh, minZone, minEqOp<label>(), labelMax);
+
+    bool error = false;
+
+    forAll(maxZone, pointI)
+    {
+        // Check point in zone on both sides
+        if (maxZone[pointI] != minZone[pointI])
+        {
+            if (report && !error)
+            {
+                Info<< " ***Problem with pointZone " << index()
+                    << " named " << name()
+                    << ". Point " << pointI
+                    << " at " << mesh.points()[pointI]
+                    << " is in zone "
+                    << (minZone[pointI] == labelMax ? -1 : minZone[pointI])
+                    << " on some processors and in zone "
+                    << maxZone[pointI]
+                    << " on some other processors."
+                    << endl;
+            }
+            error = true;
+        }
+    }
+
+    return error;
+}
+
+
 void Foam::pointZone::writeDict(Ostream& os) const
 {
     os  << nl << name_ << nl << token::BEGIN_BLOCK << nl

src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZone.H

@@ -208,6 +208,10 @@ public:
         //- Check zone definition. Return true if in error.
         virtual bool checkDefinition(const bool report = false) const;
 
+        //- Check whether zone is synchronised across coupled boundaries. Return
+        //  true if in error.
+        virtual bool checkParallelSync(const bool report = false) const;
+
         //- Correct patch after moving points
         virtual void movePoints(const pointField&)
         {}

src/finiteVolume/Make/files

@@ -16,13 +16,14 @@ $(basicFvPatches)/coupled/coupledFvPatch.C
 $(basicFvPatches)/generic/genericFvPatch.C
 
 constraintFvPatches = $(fvPatches)/constraint
-$(constraintFvPatches)/empty/emptyFvPatch.C
-$(constraintFvPatches)/symmetry/symmetryFvPatch.C
-$(constraintFvPatches)/wedge/wedgeFvPatch.C
 $(constraintFvPatches)/cyclic/cyclicFvPatch.C
 $(constraintFvPatches)/cyclicSlip/cyclicSlipFvPatch.C
+$(constraintFvPatches)/empty/emptyFvPatch.C
+$(constraintFvPatches)/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatch.C
 $(constraintFvPatches)/processor/processorFvPatch.C
 $(constraintFvPatches)/processorCyclic/processorCyclicFvPatch.C
+$(constraintFvPatches)/symmetry/symmetryFvPatch.C
+$(constraintFvPatches)/wedge/wedgeFvPatch.C
 
 derivedFvPatches = $(fvPatches)/derived
 $(derivedFvPatches)/wall/wallFvPatch.C
@@ -100,6 +101,7 @@ $(constraintFvPatchFields)/cyclic/cyclicFvPatchFields.C
 $(constraintFvPatchFields)/cyclicSlip/cyclicSlipFvPatchFields.C
 $(constraintFvPatchFields)/empty/emptyFvPatchFields.C
 $(constraintFvPatchFields)/jumpCyclic/jumpCyclicFvPatchFields.C
+$(constraintFvPatchFields)/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchFields.C
 $(constraintFvPatchFields)/processor/processorFvPatchFields.C
 $(constraintFvPatchFields)/processor/processorFvPatchScalarField.C
 $(constraintFvPatchFields)/processorCyclic/processorCyclicFvPatchFields.C
@@ -174,12 +176,12 @@ constraintFvsPatchFields = $(fvsPatchFields)/constraint
 $(constraintFvsPatchFields)/cyclic/cyclicFvsPatchFields.C
 $(constraintFvsPatchFields)/cyclicSlip/cyclicSlipFvsPatchFields.C
 $(constraintFvsPatchFields)/empty/emptyFvsPatchFields.C
+$(constraintFvsPatchFields)/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFields.C
 $(constraintFvsPatchFields)/processor/processorFvsPatchFields.C
 $(constraintFvsPatchFields)/processorCyclic/processorCyclicFvsPatchFields.C
 $(constraintFvsPatchFields)/symmetry/symmetryFvsPatchFields.C
 $(constraintFvsPatchFields)/wedge/wedgeFvsPatchFields.C
 
-
 fields/volFields/volFields.C
 fields/surfaceFields/surfaceFields.C
 

src/finiteVolume/fields/fvPatchFields/constraint/cyclic/cyclicFvPatchField.C

@@ -57,18 +57,18 @@ cyclicFvPatchField<Type>::cyclicFvPatchField
     coupledFvPatchField<Type>(ptf, p, iF, mapper),
     cyclicPatch_(refCast<const cyclicFvPatch>(p))
 {
-    if (!isType<cyclicFvPatch>(this->patch()))
+    if (!isA<cyclicFvPatch>(this->patch()))
     {
         FatalErrorIn
         (
-            "cyclicFvPatchField<Type>::cyclicFvPatchField\n"
-            "(\n"
-            "    const cyclicFvPatchField<Type>& ptf,\n"
-            "    const fvPatch& p,\n"
-            "    const DimensionedField<Type, volMesh>& iF,\n"
-            "    const fvPatchFieldMapper& mapper\n"
-            ")\n"
-        )   << "\n    patch type '" << p.type()
+            "cyclicFvPatchField<Type>::cyclicFvPatchField"
+            "("
+                "const cyclicFvPatchField<Type>& ,"
+                "const fvPatch&, "
+                "const DimensionedField<Type, volMesh>&, "
+                "const fvPatchFieldMapper&"
+            ")"
+        )   << "    patch type '" << p.type()
             << "' not constraint type '" << typeName << "'"
             << "\n    for patch " << p.name()
             << " of field " << this->dimensionedInternalField().name()
@@ -89,18 +89,18 @@ cyclicFvPatchField<Type>::cyclicFvPatchField
     coupledFvPatchField<Type>(p, iF, dict),
     cyclicPatch_(refCast<const cyclicFvPatch>(p))
 {
-    if (!isType<cyclicFvPatch>(p))
+    if (!isA<cyclicFvPatch>(p))
     {
         FatalIOErrorIn
         (
-            "cyclicFvPatchField<Type>::cyclicFvPatchField\n"
-            "(\n"
-            "    const fvPatch& p,\n"
-            "    const Field<Type>& field,\n"
-            "    const dictionary& dict\n"
-            ")\n",
+            "cyclicFvPatchField<Type>::cyclicFvPatchField"
+            "("
+                "const fvPatch&, "
+                "const Field<Type>&, "
+                "const dictionary&"
+            ")",
             dict
-        )   << "\n    patch type '" << p.type()
+        )   << "    patch type '" << p.type()
             << "' not constraint type '" << typeName << "'"
             << "\n    for patch " << p.name()
             << " of field " << this->dimensionedInternalField().name()

src/finiteVolume/fields/fvPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchField.C

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicFvPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+nonuniformTransformCyclicFvPatchField<Type>::
+nonuniformTransformCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicFvPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvPatchField<Type>::
+nonuniformTransformCyclicFvPatchField
+(
+    const nonuniformTransformCyclicFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicFvPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvPatchField<Type>::
+nonuniformTransformCyclicFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicFvPatchField<Type>(p, iF, dict)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvPatchField<Type>::
+nonuniformTransformCyclicFvPatchField
+(
+    const nonuniformTransformCyclicFvPatchField<Type>& ptf
+)
+:
+    cyclicFvPatchField<Type>(ptf)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvPatchField<Type>::
+nonuniformTransformCyclicFvPatchField
+(
+    const nonuniformTransformCyclicFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    cyclicFvPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchField.H

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicFvPatchField
+
+Description
+    Foam::nonuniformTransformCyclicFvPatchField
+
+SourceFiles
+    nonuniformTransformCyclicFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvPatchField_H
+#define nonuniformTransformCyclicFvPatchField_H
+
+#include "cyclicFvPatchField.H"
+#include "nonuniformTransformCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+              Class nonuniformTransformCyclicFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonuniformTransformCyclicFvPatchField
+:
+    public cyclicFvPatchField<Type>
+{
+    // Private data
+
+public:
+
+    //- Runtime type information
+    TypeName(nonuniformTransformCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonuniformTransformCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonuniformTransformCyclicFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        //  nonuniformTransformCyclicFvPatchField onto a new patch
+        nonuniformTransformCyclicFvPatchField
+        (
+            const nonuniformTransformCyclicFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        nonuniformTransformCyclicFvPatchField
+        (
+            const nonuniformTransformCyclicFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new nonuniformTransformCyclicFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        nonuniformTransformCyclicFvPatchField
+        (
+            const nonuniformTransformCyclicFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type> > clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new nonuniformTransformCyclicFvPatchField<Type>(*this, iF)
+            );
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "nonuniformTransformCyclicFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(nonuniformTransformCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchFields.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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvPatchFields_H
+#define nonuniformTransformCyclicFvPatchFields_H
+
+#include "nonuniformTransformCyclicFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(nonuniformTransformCyclic)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatchFieldsFwd.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvPatchFieldsFwd_H
+#define nonuniformTransformCyclicFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonuniformTransformCyclicFvPatchField;
+
+makePatchTypeFieldTypedefs(nonuniformTransformCyclic)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/cyclic/cyclicFvsPatchField.C

@@ -56,7 +56,7 @@ cyclicFvsPatchField<Type>::cyclicFvsPatchField
     coupledFvsPatchField<Type>(ptf, p, iF, mapper),
     cyclicPatch_(refCast<const cyclicFvPatch>(p))
 {
-    if (!isType<cyclicFvPatch>(this->patch()))
+    if (!isA<cyclicFvPatch>(this->patch()))
     {
         FatalErrorIn
         (
@@ -87,7 +87,7 @@ cyclicFvsPatchField<Type>::cyclicFvsPatchField
     coupledFvsPatchField<Type>(p, iF, dict),
     cyclicPatch_(refCast<const cyclicFvPatch>(p))
 {
-    if (!isType<cyclicFvPatch>(p))
+    if (!isA<cyclicFvPatch>(p))
     {
         FatalIOErrorIn
         (

src/finiteVolume/fields/fvsPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchField.C

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicFvsPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+nonuniformTransformCyclicFvsPatchField<Type>::
+nonuniformTransformCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    cyclicFvsPatchField<Type>(p, iF)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvsPatchField<Type>::
+nonuniformTransformCyclicFvsPatchField
+(
+    const nonuniformTransformCyclicFvsPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    cyclicFvsPatchField<Type>(ptf, p, iF, mapper)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvsPatchField<Type>::
+nonuniformTransformCyclicFvsPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, surfaceMesh>& iF,
+    const dictionary& dict
+)
+:
+    cyclicFvsPatchField<Type>(p, iF, dict)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvsPatchField<Type>::
+nonuniformTransformCyclicFvsPatchField
+(
+    const nonuniformTransformCyclicFvsPatchField<Type>& ptf
+)
+:
+    cyclicFvsPatchField<Type>(ptf)
+{}
+
+
+template<class Type>
+nonuniformTransformCyclicFvsPatchField<Type>::
+nonuniformTransformCyclicFvsPatchField
+(
+    const nonuniformTransformCyclicFvsPatchField<Type>& ptf,
+    const DimensionedField<Type, surfaceMesh>& iF
+)
+:
+    cyclicFvsPatchField<Type>(ptf, iF)
+{}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchField.H

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicFvsPatchField
+
+Description
+    Foam::nonuniformTransformCyclicFvsPatchField
+
+SourceFiles
+    nonuniformTransformCyclicFvsPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvsPatchField_H
+#define nonuniformTransformCyclicFvsPatchField_H
+
+#include "cyclicFvsPatchField.H"
+#include "nonuniformTransformCyclicFvPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+             Class nonuniformTransformCyclicFvsPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class nonuniformTransformCyclicFvsPatchField
+:
+    public cyclicFvsPatchField<Type>
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonuniformTransformCyclicFvPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        nonuniformTransformCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        nonuniformTransformCyclicFvsPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        //  nonuniformTransformCyclicFvsPatchField onto a new patch
+        nonuniformTransformCyclicFvsPatchField
+        (
+            const nonuniformTransformCyclicFvsPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, surfaceMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        nonuniformTransformCyclicFvsPatchField
+        (
+            const nonuniformTransformCyclicFvsPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvsPatchField<Type> > clone() const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new nonuniformTransformCyclicFvsPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        nonuniformTransformCyclicFvsPatchField
+        (
+            const nonuniformTransformCyclicFvsPatchField<Type>&,
+            const DimensionedField<Type, surfaceMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvsPatchField<Type> > clone
+        (
+            const DimensionedField<Type, surfaceMesh>& iF
+        ) const
+        {
+            return tmp<fvsPatchField<Type> >
+            (
+                new nonuniformTransformCyclicFvsPatchField<Type>(*this, iF)
+            );
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "nonuniformTransformCyclicFvsPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicFvsPatchFields.H"
+#include "fvsPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFvsPatchFields(nonuniformTransformCyclic);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFields.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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvsPatchFields_H
+#define nonuniformTransformCyclicFvsPatchFields_H
+
+#include "nonuniformTransformCyclicFvsPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFvsPatchTypeFieldTypedefs(nonuniformTransformCyclic)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvsPatchFields/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvsPatchFieldsFwd.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvsPatchFieldsFwd_H
+#define nonuniformTransformCyclicFvsPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class nonuniformTransformCyclicFvsPatchField;
+
+makeFvsPatchTypeFieldTypedefs(nonuniformTransformCyclic)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fvMesh/fvPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatch.C

@@ -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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonuniformTransformCyclicFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(nonuniformTransformCyclicFvPatch, 0);
+addToRunTimeSelectionTable
+(
+    fvPatch,
+    nonuniformTransformCyclicFvPatch,
+    polyPatch
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fvMesh/fvPatches/constraint/nonuniformTransformCyclic/nonuniformTransformCyclicFvPatch.H

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::nonuniformTransformCyclicFvPatch
+
+Description
+    Cyclic-plane patch.
+
+SourceFiles
+    nonuniformTransformCyclicFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonuniformTransformCyclicFvPatch_H
+#define nonuniformTransformCyclicFvPatch_H
+
+#include "cyclicFvPatch.H"
+#include "nonuniformTransformCyclicPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+            Class nonuniformTransformCyclicFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonuniformTransformCyclicFvPatch
+:
+    public cyclicFvPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName(nonuniformTransformCyclicPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from polyPatch
+        nonuniformTransformCyclicFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        )
+        :
+            cyclicFvPatch(patch, bm)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.H

@@ -53,7 +53,7 @@ class inverseDistanceDiffusivity
     // Private data
 
         //- Patches selected to base the distance on
-        //  These can contain regular expressions and the actuallt patch names
+        //  These can contain regular expressions and the actual patch names
         //  will be searched for.
         wordList patchNames_;
 

src/lagrangian/coalCombustion/Make/files

@@ -1,5 +1,6 @@
 /* Coal parcel and sub-models */
-CoalParcel/defineCoalParcel.C
-CoalParcel/makeCoalParcelSubmodels.C
+coalParcel/coalParcel.C
+coalParcel/defineCoalParcel.C
+coalParcel/makeCoalParcelSubmodels.C
 
 LIB = $(FOAM_LIBBIN)/libcoalCombustion

src/lagrangian/coalCombustion/Make/options

@@ -11,6 +11,7 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/solids/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/solidMixture/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
@@ -32,6 +33,7 @@ LIB_LIBS = \
     -lsolids \
     -lsolidMixture \
     -lreactionThermophysicalModels \
+    -lSLGThermo \
     -lcompressibleRASModels \
     -lcompressibleLESModels \
     -lsurfaceFilmModels

src/lagrangian/coalCombustion/coalCloud/coalCloud.H

@@ -25,29 +25,21 @@ Class
     CoalCloud
 
 Description
-    Coal cloud templated on the type of carrier phase thermodynamics
+    Coal cloud
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef CoalCloud_H
-#define CoalCloud_H
+#ifndef coalCloud_H
+#define coalCloud_H
 
 #include "ReactingMultiphaseCloud.H"
-#include "CoalParcel.H"
-#include "thermoPhysicsTypes.H"
+#include "coalParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    typedef ReactingMultiphaseCloud<CoalParcel<constGasThermoPhysics> >
-        constThermoCoalCloud;
-
-    typedef ReactingMultiphaseCloud<CoalParcel<gasThermoPhysics> >
-        thermoCoalCloud;
-
-    typedef ReactingMultiphaseCloud<CoalParcel<icoPoly8ThermoPhysics> >
-        icoPoly8ThermoCoalCloud;
+    typedef ReactingMultiphaseCloud<coalParcel> coalCloud;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/coalCombustion/coalParcel/coalParcel.C

@@ -23,26 +23,24 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "CoalParcel.H"
+#include "coalParcel.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::CoalParcel<ThermoType>::CoalParcel
+Foam::coalParcel::coalParcel
 (
-    ReactingMultiphaseCloud<CoalParcel<ThermoType> >& owner,
+    ReactingMultiphaseCloud<coalParcel>& owner,
     const vector& position,
     const label cellI
 )
 :
-    ReactingMultiphaseParcel<CoalParcel<ThermoType> >(owner, position, cellI)
+    ReactingMultiphaseParcel<coalParcel>(owner, position, cellI)
 {}
 
 
-template<class ThermoType>
-Foam::CoalParcel<ThermoType>::CoalParcel
+Foam::coalParcel::coalParcel
 (
-    ReactingMultiphaseCloud<CoalParcel<ThermoType> >& owner,
+    ReactingMultiphaseCloud<coalParcel>& owner,
     const vector& position,
     const label cellI,
     const label typeId,
@@ -56,12 +54,10 @@ Foam::CoalParcel<ThermoType>::CoalParcel
     const scalarField& YGas0,
     const scalarField& YLiquid0,
     const scalarField& YSolid0,
-    const typename
-        ReactingMultiphaseParcel<CoalParcel<ThermoType> >::
-        constantProperties& constProps
+    const ReactingMultiphaseParcel<coalParcel>::constantProperties& constProps
 )
 :
-    ReactingMultiphaseParcel<CoalParcel<ThermoType> >
+    ReactingMultiphaseParcel<coalParcel>
     (
         owner,
         position,
@@ -82,22 +78,27 @@ Foam::CoalParcel<ThermoType>::CoalParcel
 {}
 
 
-template<class ThermoType>
-Foam::CoalParcel<ThermoType>::CoalParcel
+Foam::coalParcel::coalParcel
 (
-    const Cloud<CoalParcel<ThermoType> >& cloud,
+    const Cloud<coalParcel>& cloud,
     Istream& is,
     bool readFields
 )
 :
-    ReactingMultiphaseParcel<CoalParcel<ThermoType> >(cloud, is, readFields)
+    ReactingMultiphaseParcel<coalParcel>(cloud, is, readFields)
 {}
 
 
+Foam::coalParcel::coalParcel(const coalParcel& p)
+:
+    ReactingMultiphaseParcel<coalParcel>(p)
+{
+}
+
+
 // * * * * * * * * * * * * * * * *  Destructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::CoalParcel<ThermoType>::~CoalParcel()
+Foam::coalParcel::~coalParcel()
 {}
 
 

src/lagrangian/coalCombustion/coalParcel/coalParcel.H

@@ -22,19 +22,18 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    CoalParcel
+    coalParcel
 
 Description
-
+    Coal parcel class
 
 SourceFiles
     CoalParcel.C
-    CoalParcelIO.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef CoalParcel_H
-#define CoalParcel_H
+#ifndef coalParcel_H
+#define coalParcel_H
 
 #include "ReactingMultiphaseParcel.H"
 
@@ -43,42 +42,34 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-template<class ThermoType>
-class CoalParcel;
-
 /*---------------------------------------------------------------------------*\
-                         Class CoalParcel Declaration
+                         Class coalParcel Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class ThermoType>
-class CoalParcel
+class coalParcel
 :
-    public ReactingMultiphaseParcel<CoalParcel<ThermoType> >
+    public ReactingMultiphaseParcel<coalParcel>
 {
 public:
 
-    //- The type of thermodynamics this parcel was instantiated for
-    typedef ThermoType thermoType;
-
     // Run-time type information
-    TypeName("CoalParcel");
+    TypeName("coalParcel");
 
     // Constructors
 
         //- Construct from owner, position, and cloud owner
         //  Other properties initialised as null
-        CoalParcel
+        coalParcel
         (
-             ReactingMultiphaseCloud<CoalParcel>& owner,
+             ReactingMultiphaseCloud<coalParcel>& owner,
              const vector& position,
              const label cellI
         );
 
         //- Construct from components
-        CoalParcel
+        coalParcel
         (
-             ReactingMultiphaseCloud<CoalParcel>& owner,
+             ReactingMultiphaseCloud<coalParcel>& owner,
              const vector& position,
              const label cellI,
              const label typeId,
@@ -92,28 +83,30 @@ public:
              const scalarField& YGas0,
              const scalarField& YLiquid0,
              const scalarField& YSolid0,
-             const typename
-                 ReactingMultiphaseParcel<CoalParcel>::
-                 constantProperties& constProps
+             const ReactingMultiphaseParcel<coalParcel>::constantProperties&
+                 constProps
         );
 
         //- Construct from Istream
-        CoalParcel
+        coalParcel
         (
-            const Cloud<CoalParcel>& c,
+            const Cloud<coalParcel>& c,
             Istream& is,
             bool readFields = true
         );
 
+        //- Construct as a copy
+        coalParcel(const coalParcel& p);
+
         //- Construct and return a clone
-        autoPtr<CoalParcel> clone() const
+        autoPtr<coalParcel> clone() const
         {
-            return autoPtr<CoalParcel>(new CoalParcel(*this));
+            return autoPtr<coalParcel>(new coalParcel(*this));
         }
 
 
     //- Destructor
-    virtual ~CoalParcel();
+    virtual ~coalParcel();
 };
 
 
@@ -123,12 +116,6 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "CoalParcel.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //

src/lagrangian/coalCombustion/coalParcel/defineCoalParcel.C

@@ -23,14 +23,14 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "createCoalParcelTypes.H"
-#include "CoalParcel.H"
+#include "createReactingMultiphaseParcelTypes.H"
+#include "coalParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    createCoalParcelType(CoalParcel);
+    createReactingMultiphaseParcelTypes(coalParcel);
 };
 
 

src/lagrangian/coalCombustion/coalParcel/makeCoalParcelSubmodels.C

@@ -23,26 +23,26 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "CoalParcel.H"
+#include "coalParcel.H"
 
 // Kinematic
-#include "makeReactingParcelDispersionModels.H"
-#include "makeReactingParcelDragModels.H"
+#include "makeParcelDispersionModels.H"
+#include "makeParcelDragModels.H"
 #include "makeReactingMultiphaseParcelInjectionModels.H" // MP variant
-#include "makeReactingParcelCollisionModels.H"
-#include "makeReactingParcelPatchInteractionModels.H"
-#include "makeReactingParcelPostProcessingModels.H"
+#include "makeParcelCollisionModels.H"
+#include "makeParcelPatchInteractionModels.H"
+#include "makeParcelPostProcessingModels.H"
 
 // Thermodynamic
-#include "makeReactingParcelHeatTransferModels.H"
+#include "makeParcelHeatTransferModels.H"
 
 // Reacting
 #include "makeReactingMultiphaseParcelCompositionModels.H" // MP variant
 #include "makeReactingParcelPhaseChangeModels.H"
+#include "makeReactingParcelSurfaceFilmModels.H"
 
 // Reacting multiphase
 #include "makeReactingMultiphaseParcelDevolatilisationModels.H"
-#include "makeReactingMultiphaseParcelSurfaceFilmModels.H"
 
 // Coal specific
 #include "makeCoalParcelSurfaceReactionModels.H"
@@ -52,24 +52,24 @@ License
 namespace Foam
 {
     // Kinematic sub-models
-    makeReactingDispersionModels(CoalParcel);
-    makeReactingDragModels(CoalParcel);
-    makeReactingMultiphaseInjectionModels(CoalParcel);
-    makeReactingCollisionModels(CoalParcel);
-    makeReactingPatchInteractionModels(CoalParcel);
-    makeReactingPostProcessingModels(CoalParcel);
+    makeParcelDispersionModels(coalParcel);
+    makeParcelDragModels(coalParcel);
+    makeReactingMultiphaseParcelInjectionModels(coalParcel);
+    makeParcelCollisionModels(coalParcel);
+    makeParcelPatchInteractionModels(coalParcel);
+    makeParcelPostProcessingModels(coalParcel);
 
     // Thermo sub-models
-    makeReactingHeatTransferModels(CoalParcel);
+    makeParcelHeatTransferModels(coalParcel);
 
     // Reacting sub-models
-    makeReactingMultiphaseCompositionModels(CoalParcel);
-    makeReactingPhaseChangeModels(CoalParcel);
+    makeReactingMultiphaseParcelCompositionModels(coalParcel);
+    makeReactingParcelPhaseChangeModels(coalParcel);
 
     // Reacting multiphase sub-models
-    makeReactingMultiphaseDevolatilisationModels(CoalParcel);
-    makeReactingMultiphaseSurfaceFilmModels(CoalParcel);
-    makeCoalSurfaceReactionModels(CoalParcel);
+    makeReactingMultiphaseParcelDevolatilisationModels(coalParcel);
+    makeReactingParcelSurfaceFilmModels(coalParcel);
+    makeCoalParcelSurfaceReactionModels(coalParcel);
 };
 
 

src/lagrangian/coalCombustion/include/createCoalParcelTypes.H

@@ -1,98 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef createCoalParcelTypes_H
-#define createCoalParcelTypes_H
-
-#include "thermoPhysicsTypes.H"
-#include "CoalCloud.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define createCoalParcelType(ParcelType)                                      \
-                                                                              \
-    createCoalParcelThermoType                                                \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    createCoalParcelThermoType                                                \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    createCoalParcelThermoType                                                \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define createCoalParcelThermoType(ParcelType, ThermoType)                    \
-                                                                              \
-    typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
-                                                                              \
-    defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
-    defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
-    defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicParcel<ParcelType##ThermoType>, 0); \
-    defineTemplateTypeNameAndDebug                                            \
-    (                                                                         \
-        KinematicParcel<ParcelType##ThermoType>,                              \
-        0                                                                     \
-    );                                                                        \
-    defineParcelTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);    \
-    defineTemplateTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);  \
-    defineTemplateTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);\
-    defineParcelTypeNameAndDebug                                              \
-    (                                                                         \
-        ReactingMultiphaseParcel<ParcelType##ThermoType>,                     \
-        0                                                                     \
-    );                                                                        \
-    defineTemplateTypeNameAndDebug                                            \
-    (                                                                         \
-        ReactingMultiphaseParcel<ParcelType##ThermoType>,                     \
-        0                                                                     \
-    );                                                                        \
-    defineParcelTypeNameAndDebug(CoalParcel<ParcelType##ThermoType>, 0);      \
-    defineTemplateTypeNameAndDebug(CoalParcel<ParcelType##ThermoType>, 0);    \
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicCloud<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ThermoCloud<ParcelType##ThermoType>, 0);     \
-    defineParcelTypeNameAndDebug(ReactingCloud<ParcelType##ThermoType>, 0);   \
-    defineParcelTypeNameAndDebug                                              \
-    (                                                                         \
-        ReactingMultiphaseCloud<ParcelType##ThermoType>,                      \
-        0                                                                     \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/lagrangian/coalCombustion/include/makeCoalParcelSurfaceReactionModels.H

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "ReactingMultiphaseCloud.H"
 
 #include "NoSurfaceReaction.H"
@@ -38,59 +37,33 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeCoalSurfaceReactionModels(ParcelType)                             \
+#define makeCoalParcelSurfaceReactionModels(ParcelType)                       \
                                                                               \
-    makeCoalSurfaceReactionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeCoalSurfaceReactionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeCoalSurfaceReactionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeCoalSurfaceReactionModelThermoType(ParcelType, ThermoType)        \
+    makeSurfaceReactionModel(ReactingMultiphaseCloud<ParcelType>);            \
                                                                               \
-    makeSurfaceReactionModel                                                  \
-    (                                                                         \
-        ReactingMultiphaseCloud<ParcelType<ThermoType> >                      \
-    );                                                                        \
-                                                                              \
-    makeSurfaceReactionModelThermoType                                        \
+    makeSurfaceReactionModelType                                              \
     (                                                                         \
         NoSurfaceReaction,                                                    \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeSurfaceReactionModelThermoType                                        \
+    makeSurfaceReactionModelType                                              \
     (                                                                         \
         COxidationDiffusionLimitedRate,                                       \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeSurfaceReactionModelThermoType                                        \
+    makeSurfaceReactionModelType                                              \
     (                                                                         \
         COxidationKineticDiffusionLimitedRate,                                \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeSurfaceReactionModelThermoType                                        \
+    makeSurfaceReactionModelType                                              \
     (                                                                         \
         COxidationMurphyShaddix,                                              \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationDiffusionLimitedRate/COxidationDiffusionLimitedRate.C

@@ -50,10 +50,10 @@ Foam::COxidationDiffusionLimitedRate<CloudType>::COxidationDiffusionLimitedRate
     CsLocalId_ = owner.composition().localId(idSolid, "C");
 
     // Set local copies of thermo properties
-    WO2_ = owner.mcCarrierThermo().speciesData()[O2GlobalId_].W();
-    scalar WCO2 = owner.mcCarrierThermo().speciesData()[CO2GlobalId_].W();
+    WO2_ = owner.thermo().carrier().W(O2GlobalId_);
+    const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
     WC_ = WCO2 - WO2_;
-    HcCO2_ = owner.mcCarrierThermo().speciesData()[CO2GlobalId_].Hc();
+    HcCO2_ = owner.thermo().carrier().Hc(CO2GlobalId_);
 
     if (Sb_ < 0)
     {
@@ -120,7 +120,7 @@ Foam::scalar Foam::COxidationDiffusionLimitedRate<CloudType>::calculate
     }
 
     // Local mass fraction of O2 in the carrier phase
-    const scalar YO2 = this->owner().mcCarrierThermo().Y(O2GlobalId_)[cellI];
+    const scalar YO2 = this->owner().thermo().carrier().Y(O2GlobalId_)[cellI];
 
     // Change in C mass [kg]
     scalar dmC =

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationKineticDiffusionLimitedRate/COxidationKineticDiffusionLimitedRate.C

@@ -58,10 +58,10 @@ COxidationKineticDiffusionLimitedRate
     CsLocalId_ = owner.composition().localId(idSolid, "C");
 
     // Set local copies of thermo properties
-    WO2_ = owner.mcCarrierThermo().speciesData()[O2GlobalId_].W();
-    scalar WCO2 = owner.mcCarrierThermo().speciesData()[CO2GlobalId_].W();
+    WO2_ = owner.thermo().carrier().W(O2GlobalId_);
+    const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
     WC_ = WCO2 - WO2_;
-    HcCO2_ = owner.mcCarrierThermo().speciesData()[CO2GlobalId_].Hc();
+    HcCO2_ = owner.thermo().carrier().Hc(CO2GlobalId_);
 
     if (Sb_ < 0)
     {
@@ -128,7 +128,7 @@ Foam::scalar Foam::COxidationKineticDiffusionLimitedRate<CloudType>::calculate
     }
 
     // Local mass fraction of O2 in the carrier phase
-    const scalar YO2 = this->owner().mcCarrierThermo().Y(O2GlobalId_)[cellI];
+    const scalar YO2 = this->owner().thermo().carrier().Y(O2GlobalId_)[cellI];
 
     // Diffusion rate coefficient
     const scalar D0 = C1_/d*pow(0.5*(T + Tc), 0.75);

src/lagrangian/coalCombustion/submodels/surfaceReactionModel/COxidationMurphyShaddix/COxidationMurphyShaddix.C

@@ -69,8 +69,8 @@ Foam::COxidationMurphyShaddix<CloudType>::COxidationMurphyShaddix
     CsLocalId_ = owner.composition().localId(idSolid, "C");
 
     // Set local copies of thermo properties
-    WO2_ = owner.mcCarrierThermo().speciesData()[O2GlobalId_].W();
-    scalar WCO2 = owner.mcCarrierThermo().speciesData()[CO2GlobalId_].W();
+    WO2_ = owner.thermo().carrier().W(O2GlobalId_);
+    const scalar WCO2 = owner.thermo().carrier().W(CO2GlobalId_);
     WC_ = WCO2 - WO2_;
 }
 
@@ -125,7 +125,7 @@ Foam::scalar Foam::COxidationMurphyShaddix<CloudType>::calculate
 
     // Cell carrier phase O2 species density [kg/m^3]
     const scalar rhoO2 =
-        rhoc*this->owner().mcCarrierThermo().Y(O2GlobalId_)[cellI];
+        rhoc*this->owner().thermo().carrier().Y(O2GlobalId_)[cellI];
 
     if (rhoO2 < SMALL)
     {
@@ -207,10 +207,8 @@ Foam::scalar Foam::COxidationMurphyShaddix<CloudType>::calculate
     const scalar HC =
         this->owner().composition().solids().properties()[CsLocalId_].Hf()
       + this->owner().composition().solids().properties()[CsLocalId_].cp()*T;
-    const scalar HCO2 =
-        this->owner().mcCarrierThermo().speciesData()[CO2GlobalId_].H(T);
-    const scalar HO2 =
-        this->owner().mcCarrierThermo().speciesData()[O2GlobalId_].H(T);
+    const scalar HCO2 = this->owner().thermo().carrier().H(CO2GlobalId_, T);
+    const scalar HO2 = this->owner().thermo().carrier().H(O2GlobalId_, T);
 
     // Heat of reaction
     return dOmega*(WC_*HC + WO2_*HO2 - (WC_ + WO2_)*HCO2);

src/lagrangian/dieselSpray/parcel/parcel.C

@@ -579,7 +579,7 @@ void Foam::parcel::updateParcelProperties
             {
                 // can not go above boiling temperature
                 scalar Terr = 1.0e-3;
-                label n=0;
+                label n = 0;
                 scalar dT = 1.0;
                 scalar pOld = pAtSurface;
                 while (dT > Terr)

src/lagrangian/dieselSpray/spraySubModels/collisionModel/ORourke/sameCell.H

@@ -13,7 +13,8 @@ spray::iterator pMax = p2;
 scalar dMin = pMin().d();
 scalar dMax = pMax().d();
 
-if (dMin > dMax) {
+if (dMin > dMax)
+{
     dMin = pMax().d();
     dMax = pMin().d();
     pMin = p2;
@@ -31,13 +32,14 @@ scalar nMin = pMin().N(rhoMin);
 
 scalar mdMin = mMin/nMin;
 
-scalar nu0 = 0.25*constant::mathematical::pi*sumD*sumD*magVRel*dt/vols_[cell1];
+scalar nu0 = 0.25*constant::mathematical::pi*sqr(sumD)*magVRel*dt/vols_[cell1];
 scalar nu = nMin*nu0;
 scalar collProb = exp(-nu);
 scalar xx = rndGen_.scalar01();
 
-// collision occur
-if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
+if ((xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL))
+{
+    // collision occurs
 
     scalar gamma = dMax/max(dMin, 1.0e-12);
     scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
@@ -63,8 +65,8 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
     scalar prob = rndGen_.scalar01();
 
     // Coalescence
-    if ( prob < coalesceProb && coalescence_) {
-
+    if (prob < coalesceProb && coalescence_)
+    {
         // How 'many' of the droplets coalesce
         // This is the kiva way ... which actually works best
 
@@ -73,14 +75,17 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
         label n=2;
 
         // xx > collProb=zz
-        while ((zz < xx) && (n<1000)) {
+        while ((zz < xx) && (n<1000))
+        {
             zz += vnu;
             vnu *= nu/n;
+            n++;
         }
-        //Info<< "vnu = " << vnu << ", n = " << n << endl;
         scalar nProb = n - 1;
+
         // All droplets coalesce
-        if (nProb*nMax > nMin) {
+        if (nProb*nMax > nMin)
+        {
             nProb = nMin/nMax;
         }
 
@@ -93,7 +98,7 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
 
         pMax().T() = (averageTemp*mTot - newMinMass*pMin().T())/newMaxMass;
         rhoMax = spray_.fuels().rho(pc, pMax().T(), pMax().X());
-        scalar d3 = pow(dMax, 3) + nProb*pow(dMin,3);
+        scalar d3 = pow3(dMax) + nProb*pow3(dMin);
         pMax().d() = cbrt(d3);
         pMax().U() = (momMax + (1.0-newMinMass/mMin)*momMin)/newMaxMass;
 
@@ -110,14 +115,15 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
         {
             pMax().X()[i] = Ynew[i]/(spray_.fuels().properties()[i].W()*Wlinv);
         }
-
     }
-    // Grazing collision (no coalescence)
-    else {
+    else
+    {
+        // Grazing collision (no coalescence)
 
         scalar gf = sqrt(prob) - sqrt(coalesceProb);
         scalar denom = 1.0 - sqrt(coalesceProb);
-        if (denom < 1.0e-5) {
+        if (denom < 1.0e-5)
+        {
             denom = 1.0;
         }
         gf /= denom;
@@ -139,16 +145,16 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
         vector v1p = (mr + m2*gf*vRel)/(m1+m2);
         vector v2p = (mr - m1*gf*vRel)/(m1+m2);
 
-        if (n1 < n2) {
+        if (n1 < n2)
+        {
             p1().U() = v1p;
             p2().U() = (n1*v2p + (n2-n1)*v2)/n2;
         }
-        else {
+        else
+        {
             p1().U() = (n2*v1p + (n1-n2)*v1)/n1;
             p2().U() = v2p;
         }
-
-    } // if - coalescence or not
-
-} // if - collision
+    }
+}
 

src/lagrangian/intermediate/Make/files

@@ -33,13 +33,15 @@ $(THERMOPARCEL)/makeBasicThermoParcelSubmodels.C
 
 
 /* reacting parcel sub-models */
-REACTINGPARCEL=$(DERIVEDPARCELS)/BasicReactingParcel
+REACTINGPARCEL=$(DERIVEDPARCELS)/basicReactingParcel
+$(REACTINGPARCEL)/basicReactingParcel.C
 $(REACTINGPARCEL)/defineBasicReactingParcel.C
 $(REACTINGPARCEL)/makeBasicReactingParcelSubmodels.C
 
 
 /* reacting multiphase parcel sub-models */
-REACTINGMPPARCEL=$(DERIVEDPARCELS)/BasicReactingMultiphaseParcel
+REACTINGMPPARCEL=$(DERIVEDPARCELS)/basicReactingMultiphaseParcel
+$(REACTINGMPPARCEL)/basicReactingMultiphaseParcel.C
 $(REACTINGMPPARCEL)/defineBasicReactingMultiphaseParcel.C
 $(REACTINGMPPARCEL)/makeBasicReactingMultiphaseParcelSubmodels.C
 
@@ -49,9 +51,6 @@ RADIATION=submodels/addOns/radiation
 $(RADIATION)/absorptionEmission/cloudAbsorptionEmission/cloudAbsorptionEmission.C
 $(RADIATION)/scatter/cloudScatter/cloudScatter.C
 
-SURFACEFILM=submodels/addOns/surfaceFilmModel
-$(SURFACEFILM)/injection/cloudInjection/cloudInjection.C
-
 submodels/Kinematic/PatchInteractionModel/LocalInteraction/patchInteractionData.C
 
 KINEMATICINJECTION=submodels/Kinematic/InjectionModel

src/lagrangian/intermediate/Make/options

@@ -10,6 +10,7 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/solids/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/solidMixture/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
     -I$(LIB_SRC)/turbulenceModels \
     -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
@@ -19,7 +20,6 @@ EXE_INC = \
     -I$(LIB_SRC)/surfaceFilmModels/lnInclude
 
 LIB_LIBS = \
-    -lsurfaceFilmModels \
     -lfiniteVolume \
     -lmeshTools \
     -llagrangian \
@@ -31,8 +31,10 @@ LIB_LIBS = \
     -lspecie \
     -lbasicThermophysicalModels \
     -lreactionThermophysicalModels \
+    -lSLGThermo \
     -lchemistryModel \
     -lradiation \
     -lODE \
     -lcompressibleRASModels \
-    -lcompressibleLESModels
+    -lcompressibleLESModels \
+    -lsurfaceFilmModels

src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C

@@ -67,9 +67,9 @@ void Foam::ReactingCloud<ParcelType>::preEvolve()
 template<class ParcelType>
 void Foam::ReactingCloud<ParcelType>::evolveCloud()
 {
-    const volScalarField& T = this->carrierThermo().T();
-    const volScalarField cp = this->carrierThermo().Cp();
-    const volScalarField& p = this->carrierThermo().p();
+    const volScalarField& T = this->thermo().thermo().T();
+    const volScalarField cp = this->thermo().thermo().Cp();
+    const volScalarField& p = this->thermo().thermo().p();
 
     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
     (
@@ -149,17 +149,13 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo,
+    const SLGThermo& thermo,
     bool readFields
 )
 :
     ThermoCloud<ParcelType>(cloudName, rho, U, g, thermo, false),
     reactingCloud(),
     constProps_(this->particleProperties()),
-    mcCarrierThermo_
-    (
-        dynamic_cast<multiComponentMixture<thermoType>&>(thermo)
-    ),
     compositionModel_
     (
         CompositionModel<ReactingCloud<ParcelType> >::New
@@ -176,12 +172,13 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
             *this
         )
     ),
-    rhoTrans_(mcCarrierThermo_.species().size()),
+    rhoTrans_(thermo.carrier().species().size()),
     dMassPhaseChange_(0.0)
 {
     // Set storage for mass source fields and initialise to zero
     forAll(rhoTrans_, i)
     {
+        const word& specieName = thermo.carrier().species()[i];
         rhoTrans_.set
         (
             i,
@@ -189,7 +186,7 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
             (
                 IOobject
                 (
-                    this->name() + "rhoTrans_" + mcCarrierThermo_.species()[i],
+                    this->name() + "rhoTrans_" + specieName,
                     this->db().time().timeName(),
                     this->db(),
                     IOobject::NO_READ,

src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H

@@ -42,7 +42,6 @@ SourceFiles
 
 #include "ThermoCloud.H"
 #include "reactingCloud.H"
-#include "multiComponentMixture.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -67,11 +66,6 @@ class ReactingCloud
     public ThermoCloud<ParcelType>,
     public reactingCloud
 {
-public:
-
-    //- Type of thermodynamics the cloud was instantiated for
-    typedef typename ParcelType::thermoType thermoType;
-
 
 private:
 
@@ -91,9 +85,6 @@ protected:
         //- Parcel constant properties
         typename ParcelType::constantProperties constProps_;
 
-        //- Multi-component carrier phase thermo
-        multiComponentMixture<thermoType>& mcCarrierThermo_;
-
 
         // References to the cloud sub-models
 
@@ -154,7 +145,7 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo,
+            const SLGThermo& thermo,
             bool readFields = true
         );
 
@@ -175,13 +166,6 @@ public:
             inline const typename ParcelType::constantProperties&
                 constProps() const;
 
-            //- Return const access to multi-component carrier phase thermo
-            inline const multiComponentMixture<thermoType>&
-                mcCarrierThermo() const;
-
-            //- Return access to multi-component carrier phase thermo
-            inline multiComponentMixture<thermoType>& mcCarrierThermo();
-
 
             // Sub-models
 

src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloudI.H

@@ -33,22 +33,6 @@ Foam::ReactingCloud<ParcelType>::constProps() const
 }
 
 
-template<class ParcelType>
-inline const Foam::multiComponentMixture<typename ParcelType::thermoType>&
-Foam::ReactingCloud<ParcelType>::mcCarrierThermo() const
-{
-    return mcCarrierThermo_;
-}
-
-
-template<class ParcelType>
-inline Foam::multiComponentMixture<typename ParcelType::thermoType>&
-Foam::ReactingCloud<ParcelType>::mcCarrierThermo()
-{
-    return mcCarrierThermo_;
-}
-
-
 template<class ParcelType>
 inline const Foam::CompositionModel<Foam::ReactingCloud<ParcelType> >&
 Foam::ReactingCloud<ParcelType>::composition() const

src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.C

@@ -40,9 +40,9 @@ void Foam::ReactingMultiphaseCloud<ParcelType>::preEvolve()
 template<class ParcelType>
 void Foam::ReactingMultiphaseCloud<ParcelType>::evolveCloud()
 {
-    const volScalarField& T = this->carrierThermo().T();
-    const volScalarField cp = this->carrierThermo().Cp();
-    const volScalarField& p = this->carrierThermo().p();
+    const volScalarField& T = this->thermo().thermo().T();
+    const volScalarField cp = this->thermo().thermo().Cp();
+    const volScalarField& p = this->thermo().thermo().p();
 
     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
     (
@@ -122,7 +122,7 @@ Foam::ReactingMultiphaseCloud<ParcelType>::ReactingMultiphaseCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo,
+    const SLGThermo& thermo,
     bool readFields
 )
 :

src/lagrangian/intermediate/clouds/Templates/ReactingMultiphaseCloud/ReactingMultiphaseCloud.H

@@ -136,7 +136,7 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo,
+            const SLGThermo& thermo,
             bool readFields = true
         );
 

src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C

@@ -41,8 +41,8 @@ void Foam::ThermoCloud<ParcelType>::preEvolve()
 template<class ParcelType>
 void Foam::ThermoCloud<ParcelType>::evolveCloud()
 {
-    const volScalarField& T = carrierThermo_.T();
-    const volScalarField cp = carrierThermo_.Cp();
+    const volScalarField& T = thermo_.thermo().T();
+    const volScalarField cp = thermo_.thermo().Cp();
 
     autoPtr<interpolation<scalar> > rhoInterp = interpolation<scalar>::New
     (
@@ -115,7 +115,7 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
-    basicThermo& thermo,
+    const SLGThermo& thermo,
     bool readFields
 )
 :
@@ -124,13 +124,13 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
         cloudName,
         rho,
         U,
-        thermo.mu(),
+        thermo.thermo().mu(),
         g,
         false
     ),
     thermoCloud(),
     constProps_(this->particleProperties()),
-    carrierThermo_(thermo),
+    thermo_(thermo),
     heatTransferModel_
     (
         HeatTransferModel<ThermoCloud<ParcelType> >::New

src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H

@@ -41,7 +41,7 @@ SourceFiles
 
 #include "KinematicCloud.H"
 #include "thermoCloud.H"
-#include "basicThermo.H"
+#include "SLGThermo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -82,8 +82,8 @@ protected:
 
         // References to the carrier gas fields
 
-            //- Thermodynamics package (basic)
-            basicThermo& carrierThermo_;
+            //- SLG thermodynamics package
+            const SLGThermo& thermo_;
 
 
         // References to the cloud sub-models
@@ -136,7 +136,7 @@ public:
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
-            basicThermo& thermo,
+            const SLGThermo& thermo,
             bool readFields = true
         );
 
@@ -158,10 +158,7 @@ public:
                 constProps() const;
 
             //- Return const access to thermo package
-            inline const basicThermo& carrierThermo() const;
-
-            //- Return access to thermo package
-            inline basicThermo& carrierThermo();
+            inline const SLGThermo& thermo() const;
 
 
             // Sub-models

src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloudI.H

@@ -38,18 +38,9 @@ Foam::ThermoCloud<ParcelType>::constProps() const
 
 
 template<class ParcelType>
-inline const Foam::basicThermo&
-Foam::ThermoCloud<ParcelType>::carrierThermo() const
+inline const Foam::SLGThermo& Foam::ThermoCloud<ParcelType>::thermo() const
 {
-    return carrierThermo_;
-}
-
-
-template<class ParcelType>
-inline Foam::basicThermo&
-Foam::ThermoCloud<ParcelType>::carrierThermo()
-{
-    return carrierThermo_;
+    return thermo_;
 }
 
 

src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.H

@@ -22,35 +22,27 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::BasicReactingCloud
+    Foam::basicReactingCloud
 
 Description
-    Reacting cloud templated on the type of carrier phase thermodynamics
+    Cloud class to introduce reacting parcels
 
 SourceFiles
     BasicReactingCloud.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef BasicReactingCloud_H
-#define BasicReactingCloud_H
+#ifndef basicReactingCloud_H
+#define basicReactingCloud_H
 
 #include "ReactingCloud.H"
-#include "BasicReactingParcel.H"
-#include "thermoPhysicsTypes.H"
+#include "basicReactingParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    typedef ReactingCloud<BasicReactingParcel<constGasThermoPhysics> >
-        constThermoReactingCloud;
-
-    typedef ReactingCloud<BasicReactingParcel<gasThermoPhysics> >
-        thermoReactingCloud;
-
-    typedef ReactingCloud<BasicReactingParcel<icoPoly8ThermoPhysics> >
-        icoPoly8ThermoReactingCloud;
+    typedef ReactingCloud<basicReactingParcel> basicReactingCloud;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/intermediate/clouds/derived/basicReactingMultiphaseCloud/basicReactingMultiphaseCloud.H

@@ -22,20 +22,18 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::BasicReactingMultiphaseCloud
+    Foam::basicReactingMultiphaseCloud
 
 Description
-    Reacting multiphase cloud templated on the type of carrier phase
-    thermodynamics
+    Cloud class to introduce multi-phase reacting parcels
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef BasicReactingMultiphaseCloud_H
-#define BasicReactingMultiphaseCloud_H
+#ifndef basicReactingMultiphaseCloud_H
+#define basicReactingMultiphaseCloud_H
 
 #include "ReactingMultiphaseCloud.H"
-#include "BasicReactingMultiphaseParcel.H"
-#include "thermoPhysicsTypes.H"
+#include "basicReactingMultiphaseParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -43,30 +41,9 @@ namespace Foam
 {
     typedef ReactingMultiphaseCloud
         <
-            BasicReactingMultiphaseParcel
-            <
-                constGasThermoPhysics
-            >
+            basicReactingMultiphaseParcel
         >
-        constThermoReactingMultiphaseCloud;
-
-    typedef ReactingMultiphaseCloud
-        <
-            BasicReactingMultiphaseParcel
-            <
-                gasThermoPhysics
-            >
-        >
-        thermoReactingMultiphaseCloud;
-
-    typedef ReactingMultiphaseCloud
-        <
-            BasicReactingMultiphaseParcel
-            <
-                icoPoly8ThermoPhysics
-            >
-        >
-        icoPoly8ThermoReactingMultiphaseCloud;
+        basicReactingMultiphaseCloud;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -170,8 +170,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::cellValueSourceCorrection
         forAll(td.cloud().rhoTrans(), i)
         {
             scalar Y = td.cloud().rhoTrans(i)[cellI]/addedMass;
-            cpEff +=
-                Y*td.cloud().mcCarrierThermo().speciesData()[i].Cp(this->Tc_);
+            cpEff += Y*td.cloud().thermo().carrier().Cp(i, this->Tc_);
         }
     }
     const scalar cpc = td.cpInterp().psi()[cellI];
@@ -247,7 +246,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calc
     scalar NCpW = 0.0;
 
     // Surface concentrations of emitted species
-    scalarField Cs(td.cloud().mcCarrierThermo().species().size(), 0.0);
+    scalarField Cs(td.cloud().composition().carrier().species().size(), 0.0);
 
     // Calc mass and enthalpy transfer due to phase change
     calcPhaseChange
@@ -313,7 +312,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calc
     scalarField
         dMassSRCarrier
         (
-            td.cloud().mcCarrierThermo().species().size(),
+            td.cloud().composition().carrier().species().size(),
             0.0
         );
 
@@ -547,8 +546,8 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calcDevolatilisation
         const scalar beta = sqr(cbrt(15.0) + cbrt(15.0));
         const label id =
             td.cloud().composition().localToGlobalCarrierId(GAS, i);
-        const scalar Cp = td.cloud().mcCarrierThermo().speciesData()[id].Cp(Ts);
-        const scalar W = td.cloud().mcCarrierThermo().speciesData()[id].W();
+        const scalar Cp = td.cloud().thermo().carrier().Cp(id, Ts);
+        const scalar W = td.cloud().thermo().carrier().W(id);
         const scalar Ni = dMassDV[i]/(this->areaS(d)*dt*W);
 
         // Dab calc'd using API vapour mass diffusivity function

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

@@ -89,8 +89,7 @@ void Foam::ReactingParcel<ParcelType>::cellValueSourceCorrection
         forAll(td.cloud().rhoTrans(), i)
         {
             scalar Y = td.cloud().rhoTrans(i)[cellI]/addedMass;
-            cpEff +=
-                Y*td.cloud().mcCarrierThermo().speciesData()[i].Cp(this->Tc_);
+            cpEff += Y*td.cloud().composition().carrier().Cp(i, this->Tc_);
         }
     }
     const scalar cpc = td.cpInterp().psi()[cellI];
@@ -121,13 +120,13 @@ void Foam::ReactingParcel<ParcelType>::correctSurfaceValues
     }
 
     // Far field carrier  molar fractions
-    scalarField Xinf(td.cloud().mcCarrierThermo().speciesData().size());
+    scalarField Xinf(td.cloud().thermo().carrier().species().size());
 
     forAll(Xinf, i)
     {
         Xinf[i] =
-            td.cloud().mcCarrierThermo().Y(i)[cellI]
-           /td.cloud().mcCarrierThermo().speciesData()[i].W();
+            td.cloud().thermo().carrier().Y(i)[cellI]
+           /td.cloud().thermo().carrier().W(i);
     }
     Xinf /= sum(Xinf);
 
@@ -149,7 +148,7 @@ void Foam::ReactingParcel<ParcelType>::correctSurfaceValues
         const scalar Csi = Cs[i] + Xsff*Xinf[i]*CsTot;
 
         Xs[i] = (2.0*Csi + Xinf[i]*CsTot)/3.0;
-        Ys[i] = Xs[i]*td.cloud().mcCarrierThermo().speciesData()[i].W();
+        Ys[i] = Xs[i]*td.cloud().thermo().carrier().W(i);
     }
     Xs /= sum(Xs);
     Ys /= sum(Ys);
@@ -164,16 +163,13 @@ void Foam::ReactingParcel<ParcelType>::correctSurfaceValues
 
     forAll(Ys, i)
     {
-        const scalar sqrtW =
-            sqrt(td.cloud().mcCarrierThermo().speciesData()[i].W());
-        const scalar cbrtW =
-            cbrt(td.cloud().mcCarrierThermo().speciesData()[i].W());
+        const scalar sqrtW = sqrt(td.cloud().thermo().carrier().W(i));
+        const scalar cbrtW = cbrt(td.cloud().thermo().carrier().W(i));
 
-        rhos += Xs[i]*td.cloud().mcCarrierThermo().speciesData()[i].W();
-        mus += Ys[i]*sqrtW*td.cloud().mcCarrierThermo().speciesData()[i].mu(T);
-        kappa +=
-            Ys[i]*cbrtW*td.cloud().mcCarrierThermo().speciesData()[i].kappa(T);
-        cps += Xs[i]*td.cloud().mcCarrierThermo().speciesData()[i].Cp(T);
+        rhos += Xs[i]*td.cloud().thermo().carrier().W(i);
+        mus += Ys[i]*sqrtW*td.cloud().thermo().carrier().mu(i, T);
+        kappa += Ys[i]*cbrtW*td.cloud().thermo().carrier().kappa(i, T);
+        cps += Xs[i]*td.cloud().thermo().carrier().Cp(i, T);
 
         sumYiSqrtW += Ys[i]*sqrtW;
         sumYiCbrtW += Ys[i]*cbrtW;
@@ -267,7 +263,7 @@ void Foam::ReactingParcel<ParcelType>::calc
     scalar NCpW = 0.0;
 
     // Surface concentrations of emitted species
-    scalarField Cs(td.cloud().mcCarrierThermo().species().size(), 0.0);
+    scalarField Cs(td.cloud().composition().carrier().species().size(), 0.0);
 
     // Calc mass and enthalpy transfer due to phase change
     calcPhaseChange
@@ -416,10 +412,10 @@ void Foam::ReactingParcel<ParcelType>::calcPhaseChange
     scalarField& Cs
 )
 {
-    typedef PhaseChangeModel
-    <
-        typename ReactingParcel<ParcelType>::trackData::cloudType
-    > phaseChangeModelType;
+    typedef typename ReactingParcel<ParcelType>::trackData::cloudType cloudType;
+    typedef PhaseChangeModel<cloudType> phaseChangeModelType;
+    const CompositionModel<cloudType>& composition = td.cloud().composition();
+
 
     if
     (
@@ -458,9 +454,8 @@ void Foam::ReactingParcel<ParcelType>::calcPhaseChange
 
     forAll(YComponents, i)
     {
-        const label idc =
-            td.cloud().composition().localToGlobalCarrierId(idPhase, i);
-        const label idl = td.cloud().composition().globalIds(idPhase)[i];
+        const label idc = composition.localToGlobalCarrierId(idPhase, i);
+        const label idl = composition.globalIds(idPhase)[i];
 
         // Calculate enthalpy transfer
         if
@@ -469,28 +464,25 @@ void Foam::ReactingParcel<ParcelType>::calcPhaseChange
          == phaseChangeModelType::etLatentHeat
         )
         {
-            scalar hlp =
-                td.cloud().composition().liquids().properties()[idl].hl(pc_, T);
+            scalar hlp = composition.liquids().properties()[idl].hl(pc_, T);
 
             Sh -= dMassPC[i]*hlp/dt;
         }
         else
         {
             // Note: enthalpies of both phases must use the same reference
-            scalar hc = td.cloud().mcCarrierThermo().speciesData()[idc].H(T);
-            scalar hp =
-                td.cloud().composition().liquids().properties()[idl].h(pc_, T);
+            scalar hc = composition.carrier().H(idc, T);
+            scalar hp = composition.liquids().properties()[idl].h(pc_, T);
 
             Sh -= dMassPC[i]*(hc - hp)/dt;
         }
 
         // Update particle surface thermo properties
         const scalar Dab =
-            td.cloud().composition().liquids().properties()[idl].D(pc_, Ts, Wc);
+            composition.liquids().properties()[idl].D(pc_, Ts, Wc);
 
-        const scalar Cp =
-            td.cloud().mcCarrierThermo().speciesData()[idc].Cp(Ts);
-        const scalar W = td.cloud().mcCarrierThermo().speciesData()[idc].W();
+        const scalar Cp = composition.carrier().Cp(idc, Ts);
+        const scalar W = composition.carrier().W(idc);
         const scalar Ni = dMassPC[i]/(this->areaS(d)*dt*W);
 
         // Molar flux of species coming from the particle (kmol/m^2/s)

src/lagrangian/intermediate/parcels/derived/basicKinematicParcel/makeBasicKinematicParcelSubmodels.C

@@ -32,7 +32,7 @@ License
 #include "makeParcelCollisionModels.H"
 #include "makeParcelPatchInteractionModels.H"
 #include "makeParcelPostProcessingModels.H"
-#include "makeKinematicParcelSurfaceFilmModels.H"
+#include "makeParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -45,7 +45,7 @@ namespace Foam
     makeParcelCollisionModels(basicKinematicParcel);
     makeParcelPatchInteractionModels(basicKinematicParcel);
     makeParcelPostProcessingModels(basicKinematicParcel);
-    makeKinematicParcelSurfaceFilmModels(basicKinematicParcel);
+    makeParcelSurfaceFilmModels(basicKinematicParcel);
 };
 
 

src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/basicReactingMultiphaseParcel.C

@@ -23,19 +23,18 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "BasicReactingMultiphaseParcel.H"
+#include "basicReactingMultiphaseParcel.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
+Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
 (
-    ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >& owner,
+    ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
     const vector& position,
     const label cellI
 )
 :
-    ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
+    ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
     (
         owner,
         position,
@@ -44,10 +43,9 @@ Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
+Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
 (
-    ReactingMultiphaseCloud<BasicReactingMultiphaseParcel<ThermoType> >& owner,
+    ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
     const vector& position,
     const label cellI,
     const label typeId,
@@ -61,12 +59,11 @@ Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
     const scalarField& YLiquid0,
     const scalarField& YSolid0,
     const scalarField& Y0,
-    const typename
-        ReactingMultiphaseParcel<BasicReactingMultiphaseParcel>::
+    const ReactingMultiphaseParcel<basicReactingMultiphaseParcel>::
         constantProperties& constProps
 )
 :
-    ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
+    ReactingMultiphaseParcel<basicReactingMultiphaseParcel >
     (
         owner,
         position,
@@ -87,15 +84,14 @@ Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
+Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
 (
-    const Cloud<BasicReactingMultiphaseParcel<ThermoType> >& cloud,
+    const Cloud<basicReactingMultiphaseParcel>& cloud,
     Istream& is,
     bool readFields
 )
 :
-    ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
+    ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
     (
         cloud,
         is,
@@ -104,21 +100,18 @@ Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingMultiphaseParcel<ThermoType>::BasicReactingMultiphaseParcel
+Foam::basicReactingMultiphaseParcel::basicReactingMultiphaseParcel
 (
-    const BasicReactingMultiphaseParcel<ThermoType>& p
+    const basicReactingMultiphaseParcel& p
 )
 :
-    ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >(p)
+    ReactingMultiphaseParcel<basicReactingMultiphaseParcel>(p)
 {}
 
 
 // * * * * * * * * * * * * * * * *  Destructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::BasicReactingMultiphaseParcel<ThermoType>::
-~BasicReactingMultiphaseParcel()
+Foam::basicReactingMultiphaseParcel::~basicReactingMultiphaseParcel()
 {}
 
 

src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/basicReactingMultiphaseParcel.H

@@ -28,13 +28,13 @@ Description
 
 
 SourceFiles
-    BasicReactingMultiphaseParcel.C
-    BasicReactingMultiphaseParcelIO.C
+    basicReactingMultiphaseParcel.C
+    basicReactingMultiphaseParcelIO.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef BasicReactingMultiphaseParcel_H
-#define BasicReactingMultiphaseParcel_H
+#ifndef basicReactingMultiphaseParcel_H
+#define basicReactingMultiphaseParcel_H
 
 #include "ReactingMultiphaseParcel.H"
 
@@ -44,43 +44,35 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-template<class ThermoType>
-class BasicReactingMultiphaseParcel;
-
 /*---------------------------------------------------------------------------*\
-               Class BasicReactingMultiphaseParcel Declaration
+               Class basicReactingMultiphaseParcel Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class ThermoType>
-class BasicReactingMultiphaseParcel
+class basicReactingMultiphaseParcel
 :
-    public ReactingMultiphaseParcel<BasicReactingMultiphaseParcel<ThermoType> >
+    public ReactingMultiphaseParcel<basicReactingMultiphaseParcel>
 {
 
 public:
 
-    //- The type of thermodynamics this parcel was instantiated for
-    typedef ThermoType thermoType;
-
     //- Run-time type information
-    TypeName("BasicReactingMultiphaseParcel");
+    TypeName("basicReactingMultiphaseParcel");
 
     // Constructors
 
         //- Construct from owner, position, and cloud owner
         //  Other properties initialised as null
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
         (
-             ReactingMultiphaseCloud<BasicReactingMultiphaseParcel>& owner,
+             ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
              const vector& position,
              const label cellI
         );
 
         //- Construct from components
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
         (
-             ReactingMultiphaseCloud<BasicReactingMultiphaseParcel>& owner,
+             ReactingMultiphaseCloud<basicReactingMultiphaseParcel>& owner,
              const vector& position,
              const label cellI,
              const label typeId,
@@ -94,35 +86,34 @@ public:
              const scalarField& YLiquid0,
              const scalarField& YSolid0,
              const scalarField& Y0,
-             const typename
-                ReactingMultiphaseParcel<BasicReactingMultiphaseParcel>::
+             const ReactingMultiphaseParcel<basicReactingMultiphaseParcel>::
                 constantProperties& constProps
         );
 
         //- Construct from Istream
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
         (
-            const Cloud<BasicReactingMultiphaseParcel>& c,
+            const Cloud<basicReactingMultiphaseParcel>& c,
             Istream& is,
             bool readFields = true
         );
 
         //- Construct as a copy
-        BasicReactingMultiphaseParcel(const BasicReactingMultiphaseParcel& p);
+        basicReactingMultiphaseParcel(const basicReactingMultiphaseParcel& p);
 
         //- Construct and return a clone
-        autoPtr<BasicReactingMultiphaseParcel> clone() const
+        autoPtr<basicReactingMultiphaseParcel> clone() const
         {
             return
-                autoPtr<BasicReactingMultiphaseParcel>
+                autoPtr<basicReactingMultiphaseParcel>
                 (
-                    new BasicReactingMultiphaseParcel(*this)
+                    new basicReactingMultiphaseParcel(*this)
                 );
         }
 
 
     //- Destructor
-    virtual ~BasicReactingMultiphaseParcel();
+    virtual ~basicReactingMultiphaseParcel();
 };
 
 
@@ -132,12 +123,6 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "BasicReactingMultiphaseParcel.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //

src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/defineBasicReactingMultiphaseParcel.C

@@ -24,13 +24,13 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "createReactingMultiphaseParcelTypes.H"
-#include "BasicReactingMultiphaseParcel.H"
+#include "basicReactingMultiphaseParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    createReactingMultiphaseParcelType(BasicReactingMultiphaseParcel);
+    createReactingMultiphaseParcelTypes(basicReactingMultiphaseParcel);
 };
 
 

src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/makeBasicReactingMultiphaseParcelSubmodels.C

@@ -23,26 +23,26 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "BasicReactingMultiphaseParcel.H"
+#include "basicReactingMultiphaseParcel.H"
 
 // Kinematic
-#include "makeReactingParcelDispersionModels.H"
-#include "makeReactingParcelDragModels.H"
+#include "makeParcelDispersionModels.H"
+#include "makeParcelDragModels.H"
 #include "makeReactingMultiphaseParcelInjectionModels.H" // MP variant
-#include "makeReactingParcelCollisionModels.H"
-#include "makeReactingParcelPatchInteractionModels.H"
-#include "makeReactingParcelPostProcessingModels.H"
+#include "makeParcelCollisionModels.H"
+#include "makeParcelPatchInteractionModels.H"
+#include "makeParcelPostProcessingModels.H"
 
 // Thermodynamic
-#include "makeReactingParcelHeatTransferModels.H"
+#include "makeParcelHeatTransferModels.H"
 
 // Reacting
-#include "makeReactingMultiphaseParcelCompositionModels.H" // MP variant
+#include "makeReactingMultiphaseParcelCompositionModels.H" // MP Variant
 #include "makeReactingParcelPhaseChangeModels.H"
+#include "makeReactingParcelSurfaceFilmModels.H"
 
 // Reacting multiphase
 #include "makeReactingMultiphaseParcelDevolatilisationModels.H"
-#include "makeReactingMultiphaseParcelSurfaceFilmModels.H"
 #include "makeReactingMultiphaseParcelSurfaceReactionModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -50,32 +50,35 @@ License
 namespace Foam
 {
     // Kinematic sub-models
-    makeReactingDispersionModels(BasicReactingMultiphaseParcel);
-    makeReactingDragModels(BasicReactingMultiphaseParcel);
-    makeReactingMultiphaseInjectionModels(BasicReactingMultiphaseParcel);
-    makeReactingCollisionModels(BasicReactingMultiphaseParcel);
-    makeReactingPatchInteractionModels(BasicReactingMultiphaseParcel);
-    makeReactingPostProcessingModels(BasicReactingMultiphaseParcel);
+    makeParcelDispersionModels(basicReactingMultiphaseParcel);
+    makeParcelDragModels(basicReactingMultiphaseParcel);
+    makeReactingMultiphaseParcelInjectionModels(basicReactingMultiphaseParcel);
+    makeParcelCollisionModels(basicReactingMultiphaseParcel);
+    makeParcelPatchInteractionModels(basicReactingMultiphaseParcel);
+    makeParcelPostProcessingModels(basicReactingMultiphaseParcel);
 
     // Thermo sub-models
-    makeReactingHeatTransferModels(BasicReactingMultiphaseParcel);
+    makeParcelHeatTransferModels(basicReactingMultiphaseParcel);
 
     // Reacting sub-models
-    makeReactingMultiphaseCompositionModels(BasicReactingMultiphaseParcel);
-    makeReactingPhaseChangeModels(BasicReactingMultiphaseParcel);
+    makeReactingMultiphaseParcelCompositionModels
+    (
+        basicReactingMultiphaseParcel
+    );
+    makeReactingParcelPhaseChangeModels(basicReactingMultiphaseParcel);
 
     // Reacting multiphase sub-models
-    makeReactingMultiphaseDevolatilisationModels
+    makeReactingMultiphaseParcelDevolatilisationModels
     (
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
     );
-    makeReactingMultiphaseSurfaceFilmModels
+    makeReactingParcelSurfaceFilmModels
     (
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
     );
-    makeReactingMultiphaseSurfaceReactionModels
+    makeReactingMultiphaseParcelSurfaceReactionModels
     (
-        BasicReactingMultiphaseParcel
+        basicReactingMultiphaseParcel
     );
 };
 

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/basicReactingParcel.C

@@ -23,26 +23,24 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "BasicReactingParcel.H"
+#include "basicReactingParcel.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
+Foam::basicReactingParcel::basicReactingParcel
 (
-    ReactingCloud<BasicReactingParcel<ThermoType> >& owner,
+    ReactingCloud<basicReactingParcel >& owner,
     const vector& position,
     const label cellI
 )
 :
-    ReactingParcel<BasicReactingParcel<ThermoType> >(owner, position, cellI)
+    ReactingParcel<basicReactingParcel >(owner, position, cellI)
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
+Foam::basicReactingParcel::basicReactingParcel
 (
-    ReactingCloud<BasicReactingParcel<ThermoType> >& owner,
+    ReactingCloud<basicReactingParcel >& owner,
     const vector& position,
     const label cellI,
     const label typeId,
@@ -53,11 +51,10 @@ Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
     const vector& angularMomentum0,
     const vector& torque0,
     const scalarField& Y0,
-    const typename ReactingParcel<BasicReactingParcel<ThermoType> >::
-        constantProperties& constProps
+    const ReactingParcel<basicReactingParcel>::constantProperties& constProps
 )
 :
-    ReactingParcel<BasicReactingParcel<ThermoType> >
+    ReactingParcel<basicReactingParcel >
     (
         owner,
         position,
@@ -75,32 +72,29 @@ Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
+Foam::basicReactingParcel::basicReactingParcel
 (
-    const Cloud<BasicReactingParcel<ThermoType> >& cloud,
+    const Cloud<basicReactingParcel >& cloud,
     Istream& is,
     bool readFields
 )
 :
-    ReactingParcel<BasicReactingParcel<ThermoType> >(cloud, is, readFields)
+    ReactingParcel<basicReactingParcel>(cloud, is, readFields)
 {}
 
 
-template<class ThermoType>
-Foam::BasicReactingParcel<ThermoType>::BasicReactingParcel
+Foam::basicReactingParcel::basicReactingParcel
 (
-    const BasicReactingParcel<ThermoType>& p
+    const basicReactingParcel& p
 )
 :
-    ReactingParcel<BasicReactingParcel>(p)
+    ReactingParcel<basicReactingParcel>(p)
 {}
 
 
 // * * * * * * * * * * * * * * * *  Destructors  * * * * * * * * * * * * * * //
 
-template<class ThermoType>
-Foam::BasicReactingParcel<ThermoType>::~BasicReactingParcel()
+Foam::basicReactingParcel::~basicReactingParcel()
 {}
 
 

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/basicReactingParcel.H

@@ -22,19 +22,18 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::BasicReactingParcel
+    Foam::basicReactingParcel
 
 Description
 
 
 SourceFiles
-    BasicReactingParcel.C
-    BasicReactingParcelIO.C
+    basicReactingParcel.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef BasicReactingParcel_H
-#define BasicReactingParcel_H
+#ifndef basicReactingParcel_H
+#define basicReactingParcel_H
 
 #include "ReactingParcel.H"
 
@@ -43,43 +42,35 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-template<class ThermoType>
-class BasicReactingParcel;
-
 /*---------------------------------------------------------------------------*\
-                    Class BasicReactingParcel Declaration
+                    Class basicReactingParcel Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class ThermoType>
-class BasicReactingParcel
+class basicReactingParcel
 :
-    public ReactingParcel<BasicReactingParcel<ThermoType> >
+    public ReactingParcel<basicReactingParcel>
 {
 
 public:
 
-    //- The type of thermodynamics this parcel was instantiated for
-    typedef ThermoType thermoType;
-
     //- Run-time type information
-    TypeName("BasicReactingParcel");
+    TypeName("basicReactingParcel");
 
     // Constructors
 
         //- Construct from owner, position, and cloud owner
         //  Other properties initialised as null
-        BasicReactingParcel
+        basicReactingParcel
         (
-            ReactingCloud<BasicReactingParcel>& owner,
+            ReactingCloud<basicReactingParcel>& owner,
             const vector& position,
             const label cellI
         );
 
         //- Construct from components
-        BasicReactingParcel
+        basicReactingParcel
         (
-            ReactingCloud<BasicReactingParcel>& owner,
+            ReactingCloud<basicReactingParcel>& owner,
             const vector& position,
             const label cellI,
             const label typeId,
@@ -90,49 +81,50 @@ public:
             const vector& angularMomentum0,
             const vector& torque0,
             const scalarField& Y0,
-            const typename ReactingParcel<BasicReactingParcel>::
-                constantProperties& constProps
+            const ReactingParcel<basicReactingParcel>::constantProperties&
+                constProps
         );
 
         //- Construct from Istream
-        BasicReactingParcel
+        basicReactingParcel
         (
-            const Cloud<BasicReactingParcel>& c,
+            const Cloud<basicReactingParcel>& c,
             Istream& is,
             bool readFields = true
         );
 
         //- Construct as a copy
-        BasicReactingParcel(const BasicReactingParcel& p);
+        basicReactingParcel(const basicReactingParcel& p);
 
         //- Construct and return a clone
-        autoPtr<BasicReactingParcel> clone() const
+        autoPtr<basicReactingParcel> clone() const
         {
             return
-                autoPtr<BasicReactingParcel>
+                autoPtr<basicReactingParcel>
                 (
-                    new BasicReactingParcel(*this)
+                    new basicReactingParcel(*this)
                 );
         }
 
 
     //- Destructor
-    virtual ~BasicReactingParcel();
+    virtual ~basicReactingParcel();
 };
 
 
+template<>
+inline bool contiguous<basicReactingParcel>()
+{
+    return false;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "BasicReactingParcel.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/defineBasicReactingParcel.C

@@ -23,14 +23,14 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "basicReactingParcel.H"
 #include "createReactingParcelTypes.H"
-#include "BasicReactingParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    createReactingParcelType(BasicReactingParcel);
+    createReactingParcelTypes(basicReactingParcel);
 };
 
 

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/makeBasicReactingParcelSubmodels.C

@@ -23,18 +23,18 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "BasicReactingParcel.H"
+#include "basicReactingParcel.H"
 
 // Kinematic
-#include "makeReactingParcelDispersionModels.H"
-#include "makeReactingParcelDragModels.H"
-#include "makeReactingParcelInjectionModels.H"
-#include "makeReactingParcelCollisionModels.H"
-#include "makeReactingParcelPatchInteractionModels.H"
-#include "makeReactingParcelPostProcessingModels.H"
+#include "makeParcelDispersionModels.H"
+#include "makeParcelDragModels.H"
+#include "makeReactingParcelInjectionModels.H" // Reacting variant
+#include "makeParcelCollisionModels.H"
+#include "makeParcelPatchInteractionModels.H"
+#include "makeParcelPostProcessingModels.H"
 
 // Thermodynamic
-#include "makeReactingParcelHeatTransferModels.H"
+#include "makeParcelHeatTransferModels.H"
 
 // Reacting
 #include "makeReactingParcelCompositionModels.H"
@@ -46,20 +46,20 @@ License
 namespace Foam
 {
     // Kinematic sub-models
-    makeReactingDispersionModels(BasicReactingParcel);
-    makeReactingDragModels(BasicReactingParcel);
-    makeReactingInjectionModels(BasicReactingParcel);
-    makeReactingCollisionModels(BasicReactingParcel);
-    makeReactingPatchInteractionModels(BasicReactingParcel);
-    makeReactingPostProcessingModels(BasicReactingParcel);
+    makeParcelDispersionModels(basicReactingParcel);
+    makeParcelDragModels(basicReactingParcel);
+    makeReactingParcelInjectionModels(basicReactingParcel);
+    makeParcelCollisionModels(basicReactingParcel);
+    makeParcelPatchInteractionModels(basicReactingParcel);
+    makeParcelPostProcessingModels(basicReactingParcel);
 
     // Thermo sub-models
-    makeReactingHeatTransferModels(BasicReactingParcel);
+    makeParcelHeatTransferModels(basicReactingParcel);
 
     // Reacting sub-models
-    makeReactingCompositionModels(BasicReactingParcel);
-    makeReactingPhaseChangeModels(BasicReactingParcel);
-    makeReactingSurfaceFilmModels(BasicReactingParcel);
+    makeReactingParcelCompositionModels(basicReactingParcel);
+    makeReactingParcelPhaseChangeModels(basicReactingParcel);
+    makeReactingParcelSurfaceFilmModels(basicReactingParcel);
 };
 
 

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

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef createKinematicParcelTypes_H
+#define createKinematicParcelTypes_H
+
+#include "KinematicParcel.H"
+#include "KinematicCloud.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define createKinematicParcelTypes(ParcelType)                                \
+                                                                              \
+    defineTemplateTypeNameAndDebug(ParcelType, 0);                            \
+    defineTemplateTypeNameAndDebug(Particle<ParcelType>, 0);                  \
+    defineTemplateTypeNameAndDebug(Cloud<ParcelType>, 0);                     \
+                                                                              \
+    defineParcelTypeNameAndDebug(KinematicParcel<ParcelType>, 0);             \
+    defineTemplateTypeNameAndDebug(KinematicParcel<ParcelType>, 0);           \
+    defineParcelTypeNameAndDebug(KinematicCloud<ParcelType>, 0);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
+

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

@@ -26,67 +26,20 @@ License
 #ifndef createReactingMultiphaseParcelTypes_H
 #define createReactingMultiphaseParcelTypes_H
 
-#include "thermoPhysicsTypes.H"
+#include "ReactingMultiphaseParcel.H"
+#include "ReactingMultiphaseCloud.H"
+
+#include "createReactingParcelTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define createReactingMultiphaseParcelType(ParcelType)                        \
+#define createReactingMultiphaseParcelTypes(ParcelType)                       \
                                                                               \
-    createReactingMultiphaseParcelThermoType                                  \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    createReactingMultiphaseParcelThermoType                                  \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    createReactingMultiphaseParcelThermoType                                  \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define createReactingMultiphaseParcelThermoType(ParcelType, ThermoType)      \
+    createReactingParcelTypes(ParcelType);                                    \
                                                                               \
-    typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
-                                                                              \
-    defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
-    defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
-    defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicParcel<ParcelType##ThermoType>, 0); \
-    defineTemplateTypeNameAndDebug                                            \
-    (                                                                         \
-        KinematicParcel<ParcelType##ThermoType>,                              \
-        0                                                                     \
-    );                                                                        \
-    defineParcelTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);    \
-    defineTemplateTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);  \
-    defineTemplateTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);\
-    defineParcelTypeNameAndDebug                                              \
-    (                                                                         \
-        ReactingMultiphaseParcel<ParcelType##ThermoType>,                     \
-        0                                                                     \
-    );                                                                        \
-    defineTemplateTypeNameAndDebug                                            \
-    (                                                                         \
-        ReactingMultiphaseParcel<ParcelType##ThermoType>,                     \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicCloud<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ThermoCloud<ParcelType##ThermoType>, 0);     \
-    defineParcelTypeNameAndDebug(ReactingCloud<ParcelType##ThermoType>, 0);   \
-    defineParcelTypeNameAndDebug                                              \
-    (                                                                         \
-        ReactingMultiphaseCloud<ParcelType##ThermoType>,                      \
-        0                                                                     \
-    );
-
+    defineParcelTypeNameAndDebug(ReactingMultiphaseParcel<ParcelType>, 0);    \
+    defineTemplateTypeNameAndDebug(ReactingMultiphaseParcel<ParcelType>, 0);  \
+    defineParcelTypeNameAndDebug(ReactingMultiphaseCloud<ParcelType>, 0);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

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

@@ -26,39 +26,20 @@ License
 #ifndef createReactingParcelTypes_H
 #define createReactingParcelTypes_H
 
-#include "thermoPhysicsTypes.H"
+#include "ReactingParcel.H"
+#include "ReactingCloud.H"
+
+#include "createThermoParcelTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define createReactingParcelType(ParcelType)                                  \
+#define createReactingParcelTypes(ParcelType)                                 \
                                                                               \
-    createReactingParcelThermoType(ParcelType, constGasThermoPhysics);        \
-    createReactingParcelThermoType(ParcelType, gasThermoPhysics);             \
-    createReactingParcelThermoType(ParcelType, icoPoly8ThermoPhysics);
-
-
-#define createReactingParcelThermoType(ParcelType, ThermoType)                \
+    createThermoParcelTypes(ParcelType);                                      \
                                                                               \
-    typedef ParcelType<ThermoType> ParcelType##ThermoType;                    \
-                                                                              \
-    defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0);                \
-    defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0);      \
-    defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0);         \
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicParcel<ParcelType##ThermoType>, 0); \
-    defineTemplateTypeNameAndDebug                                            \
-    (                                                                         \
-        KinematicParcel<ParcelType##ThermoType>,                              \
-        0                                                                     \
-    );                                                                        \
-    defineParcelTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);    \
-    defineTemplateTypeNameAndDebug(ThermoParcel<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);  \
-    defineTemplateTypeNameAndDebug(ReactingParcel<ParcelType##ThermoType>, 0);\
-                                                                              \
-    defineParcelTypeNameAndDebug(KinematicCloud<ParcelType##ThermoType>, 0);  \
-    defineParcelTypeNameAndDebug(ThermoCloud<ParcelType##ThermoType>, 0);     \
-    defineParcelTypeNameAndDebug(ReactingCloud<ParcelType##ThermoType>, 0);
+    defineParcelTypeNameAndDebug(ReactingParcel<ParcelType>, 0);              \
+    defineTemplateTypeNameAndDebug(ReactingParcel<ParcelType>, 0);            \
+    defineParcelTypeNameAndDebug(ReactingCloud<ParcelType>, 0);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef createThermoParcelTypes_H
+#define createThermoParcelTypes_H
+
+#include "ThermoParcel.H"
+#include "ThermoCloud.H"
+
+#include "createKinematicParcelTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define createThermoParcelTypes(ParcelType)                                   \
+                                                                              \
+    createKinematicParcelTypes(ParcelType);                                   \
+                                                                              \
+    defineParcelTypeNameAndDebug(ThermoParcel<ParcelType>, 0);                \
+    defineTemplateTypeNameAndDebug(ThermoParcel<ParcelType>, 0);              \
+    defineParcelTypeNameAndDebug(ThermoCloud<ParcelType>, 0);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
+
+

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2010 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,11 +29,12 @@ License
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "KinematicCloud.H"
+
 #include "NoSurfaceFilm.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeKinematicParcelSurfaceFilmModels(ParcelType)                      \
+#define makeParcelSurfaceFilmModels(ParcelType)                               \
                                                                               \
     makeSurfaceFilmModel(KinematicCloud<ParcelType>);                         \
                                                                               \
@@ -44,8 +45,11 @@ License
         ParcelType                                                            \
     );
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
 
 // ************************************************************************* //
+
+

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

@@ -28,42 +28,20 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
-#include "ReactingCloud.H"
-
+#include "ReactingMultiphaseCloud.H"
 #include "SingleMixtureFraction.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingMultiphaseCompositionModels(ParcelType)                   \
+#define makeReactingMultiphaseParcelCompositionModels(ParcelType)             \
                                                                               \
-    makeReactingMultiphaseCompositionModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingMultiphaseCompositionModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingMultiphaseCompositionModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingMultiphaseCompositionModelThermoType(ParcelType, ThermoType)\
+    makeCompositionModel(ReactingCloud<ParcelType>);                          \
                                                                               \
-    makeCompositionModel(ReactingCloud<ParcelType<ThermoType> >);             \
-                                                                              \
-    makeCompositionModelThermoType                                            \
+    makeCompositionModelType                                                  \
     (                                                                         \
         SingleMixtureFraction,                                                \
         ReactingCloud,                                                        \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "ReactingMultiphaseCloud.H"
 
 #include "ConstantRateDevolatilisation.H"
@@ -37,52 +36,27 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingMultiphaseDevolatilisationModels(ParcelType)              \
+#define makeReactingMultiphaseParcelDevolatilisationModels(ParcelType)        \
                                                                               \
-    makeReactingMultiphaseDevolatilisationModelThermoType                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingMultiphaseDevolatilisationModelThermoType                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingMultiphaseDevolatilisationModelThermoType                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingMultiphaseDevolatilisationModelThermoType(ParcelType, ThermoType)\
+    makeDevolatilisationModel(ReactingMultiphaseCloud<ParcelType>);           \
                                                                               \
-    makeDevolatilisationModel                                                 \
-    (                                                                         \
-        ReactingMultiphaseCloud<ParcelType<ThermoType> >                      \
-    );                                                                        \
-                                                                              \
-    makeDevolatilisationModelThermoType                                       \
+    makeDevolatilisationModelType                                             \
     (                                                                         \
         ConstantRateDevolatilisation,                                         \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeDevolatilisationModelThermoType                                       \
+    makeDevolatilisationModelType                                             \
     (                                                                         \
         NoDevolatilisation,                                                   \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeDevolatilisationModelThermoType                                       \
+    makeDevolatilisationModelType                                             \
     (                                                                         \
         SingleKineticRateDevolatilisation,                                    \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -41,79 +41,51 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingMultiphaseInjectionModels(ParcelType)                     \
+#define makeReactingMultiphaseParcelInjectionModels(ParcelType)               \
                                                                               \
-    makeReactingMultiphaseInjectionModelThermoType                            \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
+    makeInjectionModel(KinematicCloud<ParcelType>);                           \
                                                                               \
-    makeReactingMultiphaseInjectionModelThermoType                            \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingMultiphaseInjectionModelThermoType                            \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingMultiphaseInjectionModelThermoType(ParcelType, ThermoType)\
-                                                                              \
-    makeInjectionModel(KinematicCloud<ParcelType<ThermoType> >);              \
-                                                                              \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ConeInjection,                                                        \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ConeInjectionMP,                                                      \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         FieldActivatedInjection,                                              \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ManualInjection,                                                      \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         NoInjection,                                                          \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         PatchInjection,                                                       \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ReactingMultiphaseLookupTableInjection,                               \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -1,74 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2009-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingMultiphaseParcelSurfaceFilmModels_H
-#define makeReactingMultiphaseParcelSurfaceFilmModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "ReactingMultiphaseCloud.H"
-
-#include "NoSurfaceFilm.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingMultiphaseSurfaceFilmModels(ParcelType)                   \
-                                                                              \
-    makeReactingMultiphaseSurfaceFilmModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingMultiphaseSurfaceFilmModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingMultiphaseSurfaceFilmModelThermoType                          \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingMultiphaseSurfaceFilmModelThermoType(ParcelType, ThermoType)\
-                                                                              \
-    makeSurfaceFilmModel(KinematicCloud<ParcelType<ThermoType> >);            \
-                                                                              \
-    makeSurfaceFilmModelThermoType                                            \
-    (                                                                         \
-        NoSurfaceFilm,                                                        \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -28,45 +28,20 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "ReactingMultiphaseCloud.H"
-
 #include "NoSurfaceReaction.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingMultiphaseSurfaceReactionModels(ParcelType)               \
+#define makeReactingMultiphaseParcelSurfaceReactionModels(ParcelType)         \
                                                                               \
-    makeReactingMultiphaseSurfaceReactionModelThermoType                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingMultiphaseSurfaceReactionModelThermoType                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingMultiphaseSurfaceReactionModelThermoType                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingMultiphaseSurfaceReactionModelThermoType(ParcelType, ThermoType)\
+    makeSurfaceReactionModel(ReactingMultiphaseCloud<ParcelType>);            \
                                                                               \
-    makeSurfaceReactionModel                                                  \
-    (                                                                         \
-        ReactingMultiphaseCloud<ParcelType<ThermoType> >                      \
-    );                                                                        \
-                                                                              \
-    makeSurfaceReactionModelThermoType                                        \
+    makeSurfaceReactionModelType                                              \
     (                                                                         \
         NoSurfaceReaction,                                                    \
         ReactingMultiphaseCloud,                                              \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -1,117 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelCollisionModels_H
-#define makeReactingParcelCollisionModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "KinematicCloud.H"
-
-#include "NoCollision.H"
-#include "PairCollision.H"
-
-#include "PairSpringSliderDashpot.H"
-
-#include "WallSpringSliderDashpot.H"
-#include "WallLocalSpringSliderDashpot.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingCollisionModels(ParcelType)                               \
-                                                                              \
-    makeReactingCollisionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-                                                                              \
-    makeReactingCollisionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingCollisionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingCollisionModelThermoType(ParcelType, ThermoType)          \
-                                                                              \
-    makeCollisionModel(KinematicCloud<ParcelType<ThermoType> >);              \
-                                                                              \
-    makeCollisionModelThermoType                                              \
-    (                                                                         \
-        NoCollision,                                                          \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-                                                                              \
-    makeCollisionModelThermoType                                              \
-    (                                                                         \
-        PairCollision,                                                        \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-                                                                              \
-    makePairModel(KinematicCloud<ParcelType<ThermoType> >);                   \
-                                                                              \
-    makePairModelThermoType                                                   \
-    (                                                                         \
-        PairSpringSliderDashpot,                                              \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-                                                                              \
-    makeWallModel(KinematicCloud<ParcelType<ThermoType> >);                   \
-                                                                              \
-    makeWallModelThermoType                                                   \
-    (                                                                         \
-        WallSpringSliderDashpot,                                              \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-                                                                              \
-    makeWallModelThermoType                                                   \
-    (                                                                         \
-        WallLocalSpringSliderDashpot,                                         \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -28,42 +28,20 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "ReactingCloud.H"
-
 #include "SinglePhaseMixture.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingCompositionModels(ParcelType)                             \
+#define makeReactingParcelCompositionModels(ParcelType)                       \
                                                                               \
-    makeReactingCompositionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingCompositionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingCompositionModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingCompositionModelThermoType(ParcelType, ThermoType)        \
+    makeCompositionModel(ReactingCloud<ParcelType>);                          \
                                                                               \
-    makeCompositionModel(ReactingCloud<ParcelType<ThermoType> >);             \
-                                                                              \
-    makeCompositionModelThermoType                                            \
+    makeCompositionModelType                                                  \
     (                                                                         \
         SinglePhaseMixture,                                                   \
         ReactingCloud,                                                        \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -1,98 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelDispersionModels_H
-#define makeReactingParcelDispersionModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "KinematicCloud.H"
-
-#include "NoDispersion.H"
-#include "GradientDispersionRAS.H"
-#include "StochasticDispersionRAS.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingDispersionModels(ParcelType)                              \
-                                                                              \
-    makeReactingDispersionModelThermoType                                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-                                                                              \
-    makeReactingDispersionModelThermoType                                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingDispersionModelThermoType                                     \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingDispersionModelThermoType(ParcelType, ThermoType)         \
-                                                                              \
-    makeDispersionModel(KinematicCloud<ParcelType<ThermoType> >);             \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        DispersionRASModel<KinematicCloud<ParcelType<ThermoType> > >,         \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    makeDispersionModelThermoType                                             \
-    (                                                                         \
-        NoDispersion,                                                         \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makeDispersionModelThermoType                                             \
-    (                                                                         \
-        GradientDispersionRAS,                                                \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makeDispersionModelThermoType                                             \
-    (                                                                         \
-        StochasticDispersionRAS,                                              \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -1,82 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelDragModels_H
-#define makeReactingParcelDragModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "KinematicCloud.H"
-
-#include "NoDrag.H"
-#include "SphereDrag.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingDragModels(ParcelType)                                    \
-                                                                              \
-    makeReactingDragModelThermoType                                           \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingDragModelThermoType                                           \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingDragModelThermoType                                           \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingDragModelThermoType(ParcelType, ThermoType)               \
-                                                                              \
-    makeDragModel(KinematicCloud<ParcelType<ThermoType> >);                   \
-                                                                              \
-    makeDragModelThermoType                                                   \
-    (                                                                         \
-        NoDrag,                                                               \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makeDragModelThermoType                                                   \
-    (                                                                         \
-        SphereDrag,                                                           \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -1,82 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelHeatTransferModels_H
-#define makeReactingParcelHeatTransferModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "ThermoCloud.H"
-
-#include "NoHeatTransfer.H"
-#include "RanzMarshall.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingHeatTransferModels(ParcelType)                            \
-                                                                              \
-    makeReactingHeatTransferModelThermoType                                   \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-    makeReactingHeatTransferModelThermoType                                   \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-    makeReactingHeatTransferModelThermoType                                   \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingHeatTransferModelThermoType(ParcelType, ThermoType)       \
-                                                                              \
-    makeHeatTransferModel(ThermoCloud<ParcelType<ThermoType> >);              \
-                                                                              \
-    makeHeatTransferModelThermoType                                           \
-    (                                                                         \
-        NoHeatTransfer,                                                       \
-        ThermoCloud,                                                          \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makeHeatTransferModelThermoType                                           \
-    (                                                                         \
-        RanzMarshall,                                                         \
-        ThermoCloud,                                                          \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "KinematicCloud.H"
 
 #include "ConeInjection.H"
@@ -41,79 +40,51 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingInjectionModels(ParcelType)                               \
+#define makeReactingParcelInjectionModels(ParcelType)                         \
                                                                               \
-    makeReactingInjectionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
+    makeInjectionModel(KinematicCloud<ParcelType>);                           \
                                                                               \
-    makeReactingInjectionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingInjectionModelThermoType                                      \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingInjectionModelThermoType(ParcelType, ThermoType)          \
-                                                                              \
-    makeInjectionModel(KinematicCloud<ParcelType<ThermoType> >);              \
-                                                                              \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ConeInjection,                                                        \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ConeInjectionMP,                                                      \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         FieldActivatedInjection,                                              \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ManualInjection,                                                      \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         NoInjection,                                                          \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         PatchInjection,                                                       \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeInjectionModelThermoType                                              \
+    makeInjectionModelType                                                    \
     (                                                                         \
         ReactingLookupTableInjection,                                         \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

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

@@ -1,92 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelPatchInteractionModels_H
-#define makeReactingParcelPatchInteractionModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "KinematicCloud.H"
-
-#include "LocalInteraction.H"
-#include "Rebound.H"
-#include "StandardWallInteraction.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingPatchInteractionModels(ParcelType)                        \
-                                                                              \
-    makeReactingPatchInteractionModelThermoType                               \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-                                                                              \
-    makeReactingPatchInteractionModelThermoType                               \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingPatchInteractionModelThermoType                               \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingPatchInteractionModelThermoType(ParcelType, ThermoType)   \
-                                                                              \
-    makePatchInteractionModel(KinematicCloud<ParcelType<ThermoType> >);       \
-                                                                              \
-    makePatchInteractionModelThermoType                                       \
-    (                                                                         \
-        LocalInteraction,                                                     \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makePatchInteractionModelThermoType                                       \
-    (                                                                         \
-        Rebound,                                                     \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makePatchInteractionModelThermoType                                       \
-    (                                                                         \
-        StandardWallInteraction,                                              \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "ReactingCloud.H"
 
 #include "NoPhaseChange.H"
@@ -36,44 +35,21 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingPhaseChangeModels(ParcelType)                             \
+#define makeReactingParcelPhaseChangeModels(ParcelType)                       \
                                                                               \
-    makeReactingPhaseChangeModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
+    makePhaseChangeModel(ReactingCloud<ParcelType>);                          \
                                                                               \
-    makeReactingPhaseChangeModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingPhaseChangeModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingPhaseChangeModelThermoType(ParcelType, ThermoType)        \
-                                                                              \
-    makePhaseChangeModel(ReactingCloud<ParcelType<ThermoType> >);             \
-                                                                              \
-    makePhaseChangeModelThermoType                                            \
+    makePhaseChangeModelType                                                  \
     (                                                                         \
         NoPhaseChange,                                                        \
         ReactingCloud,                                                        \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makePhaseChangeModelThermoType                                            \
+    makePhaseChangeModelType                                                  \
     (                                                                         \
         LiquidEvaporation,                                                    \
         ReactingCloud,                                                        \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 
@@ -82,3 +58,4 @@ License
 #endif
 
 // ************************************************************************* //
+

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

@@ -1,84 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-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 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef makeReactingParcelPostProcessingModels_H
-#define makeReactingParcelPostProcessingModels_H
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "thermoPhysicsTypes.H"
-#include "KinematicCloud.H"
-
-#include "NoPostProcessing.H"
-#include "PatchPostProcessing.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#define makeReactingPostProcessingModels(ParcelType)                          \
-                                                                              \
-    makeReactingPostProcessingModelThermoType                                 \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
-                                                                              \
-    makeReactingPostProcessingModelThermoType                                 \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingPostProcessingModelThermoType                                 \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingPostProcessingModelThermoType(ParcelType, ThermoType)     \
-                                                                              \
-    makePostProcessingModel(KinematicCloud<ParcelType<ThermoType> >);         \
-                                                                              \
-    makePostProcessingModelThermoType                                         \
-    (                                                                         \
-        NoPostProcessing,                                                     \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );                                                                        \
-    makePostProcessingModelThermoType                                         \
-    (                                                                         \
-        PatchPostProcessing,                                                  \
-        KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
-    );
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

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

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoPhysicsTypes.H"
 #include "KinematicCloud.H"
 
 #include "NoSurfaceFilm.H"
@@ -36,44 +35,21 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeReactingSurfaceFilmModels(ParcelType)                             \
+#define makeReactingParcelSurfaceFilmModels(ParcelType)                       \
                                                                               \
-    makeReactingSurfaceFilmModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        constGasThermoPhysics                                                 \
-    );                                                                        \
+    makeSurfaceFilmModel(KinematicCloud<ParcelType>);                         \
                                                                               \
-    makeReactingSurfaceFilmModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        gasThermoPhysics                                                      \
-    );                                                                        \
-                                                                              \
-    makeReactingSurfaceFilmModelThermoType                                    \
-    (                                                                         \
-        ParcelType,                                                           \
-        icoPoly8ThermoPhysics                                                 \
-    );
-
-
-#define makeReactingSurfaceFilmModelThermoType(ParcelType, ThermoType)        \
-                                                                              \
-    makeSurfaceFilmModel(KinematicCloud<ParcelType<ThermoType> >);            \
-                                                                              \
-    makeSurfaceFilmModelThermoType                                            \
+    makeSurfaceFilmModelType                                                  \
     (                                                                         \
         NoSurfaceFilm,                                                        \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );                                                                        \
-    makeSurfaceFilmModelThermoType                                            \
+    makeSurfaceFilmModelType                                                  \
     (                                                                         \
         ThermoSurfaceFilm,                                                    \
         KinematicCloud,                                                       \
-        ParcelType,                                                           \
-        ThermoType                                                            \
+        ParcelType                                                            \
     );
 
 

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/CollisionModel/CollisionModel.H

@@ -172,21 +172,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makeCollisionModelThermoType(SS, CloudType, ParcelType, ThermoType)   \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    CollisionModel<CloudType<ParcelType<ThermoType> > >::                     \
-        adddictionaryConstructorToTable                                       \
-        <SS<CloudType<ParcelType<ThermoType> > > >                            \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "CollisionModelI.H"

src/lagrangian/intermediate/submodels/Kinematic/DispersionModel/DispersionModel/DispersionModel.H

@@ -162,20 +162,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makeDispersionModelThermoType(SS, CloudType, ParcelType, ThermoType)  \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    DispersionModel<CloudType<ParcelType<ThermoType> > >::                    \
-        adddictionaryConstructorToTable                                       \
-            <SS<CloudType<ParcelType<ThermoType> > > >                        \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository

src/lagrangian/intermediate/submodels/Kinematic/DragModel/DragModel/DragModel.H

@@ -147,20 +147,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makeDragModelThermoType(SS, CloudType, ParcelType, ThermoType)        \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    DragModel<CloudType<ParcelType<ThermoType> > >::                          \
-        adddictionaryConstructorToTable                                       \
-            <SS<CloudType<ParcelType<ThermoType> > > >                        \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.H

@@ -357,21 +357,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makeInjectionModelThermoType(SS, CloudType, ParcelType, ThermoType)   \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    InjectionModel<CloudType<ParcelType<ThermoType> > >::                     \
-        adddictionaryConstructorToTable                                       \
-        <SS<CloudType<ParcelType<ThermoType> > > >                            \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "InjectionModelI.H"

src/lagrangian/intermediate/submodels/Kinematic/PatchInteractionModel/PatchInteractionModel/PatchInteractionModel.H

@@ -187,20 +187,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makePatchInteractionModelThermoType(SS, CloudType, ParcelType, ThermoType)\
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    PatchInteractionModel<CloudType<ParcelType<ThermoType> > >::              \
-        adddictionaryConstructorToTable                                       \
-            <SS<CloudType<ParcelType<ThermoType> > > >                        \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PostProcessingModel/PostProcessingModel.H

@@ -177,20 +177,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makePostProcessingModelThermoType(SS, CloudType, ParcelType, ThermoType)\
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    PostProcessingModel<CloudType<ParcelType<ThermoType> > >::                \
-        adddictionaryConstructorToTable                                       \
-            <SS<CloudType<ParcelType<ThermoType> > > >                        \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "PostProcessingModelI.H"

src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.C

@@ -40,7 +40,6 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel(CloudType& owner)
     g_(dimensionedVector("zero", dimAcceleration, vector::zero)),
     coeffDict_(dictionary::null),
     active_(false),
-    injectorCellsPatch_(0),
     massParcelPatch_(0),
     diameterParcelPatch_(0),
     UFilmPatch_(0),
@@ -64,7 +63,6 @@ Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel
     g_(g),
     coeffDict_(dict.subDict(type + "Coeffs")),
     active_(true),
-    injectorCellsPatch_(0),
     massParcelPatch_(0),
     diameterParcelPatch_(0),
     UFilmPatch_(0),
@@ -112,17 +110,17 @@ void Foam::SurfaceFilmModel<CloudType>::inject(TrackData& td)
                  this->owner().mesh().boundaryMesh()[primaryPatchI]
             );
 
-        injectorCellsPatch_ = wpp.faceCells();
+        const labelList& injectorCellsPatch = wpp.faceCells();
 
         const label filmPatchI = filmPatches[i];
         const mapDistribute& distMap = wpp.map();
         cacheFilmFields(filmPatchI, distMap, filmModel);
 
-        forAll(injectorCellsPatch_, j)
+        forAll(injectorCellsPatch, j)
         {
             if (diameterParcelPatch_[j] > 0)
             {
-                const label cellI = injectorCellsPatch_[j];
+                const label cellI = injectorCellsPatch[j];
                 const point& pos = this->owner().mesh().C()[cellI];
 
                 // Create a new parcel
@@ -159,7 +157,7 @@ void Foam::SurfaceFilmModel<CloudType>::cacheFilmFields
         filmModel.diametersForPrimary().boundaryField()[filmPatchI];
     distMap.distribute(diameterParcelPatch_);
 
-    UFilmPatch_ = filmModel.U().boundaryField()[filmPatchI];
+    UFilmPatch_ = filmModel.Us().boundaryField()[filmPatchI];
     distMap.distribute(UFilmPatch_);
 
     rhoFilmPatch_ = filmModel.rho().boundaryField()[filmPatchI];

src/lagrangian/intermediate/submodels/Kinematic/SurfaceFilmModel/SurfaceFilmModel/SurfaceFilmModel.H

@@ -85,9 +85,6 @@ protected:
 
         // Cached injector fields per film patch
 
-            //- Injector cell / patch face
-            labelList injectorCellsPatch_;
-
             //- Parcel mass / patch face
             scalarList massParcelPatch_;
 
@@ -263,21 +260,6 @@ public:
             add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
-#define makeSurfaceFilmModelThermoType(SS, CloudType, ParcelType, ThermoType) \
-                                                                              \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
-                                                                              \
-    SurfaceFilmModel<CloudType<ParcelType<ThermoType> > >::                   \
-        adddictionaryConstructorToTable                                       \
-        <SS<CloudType<ParcelType<ThermoType> > > >                            \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
-
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "SurfaceFilmModelI.H"

src/lagrangian/intermediate/submodels/Reacting/CompositionModel/CompositionModel/CompositionModel.C

@@ -38,33 +38,13 @@ Foam::CompositionModel<CloudType>::CompositionModel
     dict_(dict),
     owner_(owner),
     coeffDict_(dict.subDict(type + "Coeffs")),
-    mcCarrierThermo_(owner.mcCarrierThermo()),
-    liquids_
-    (
-        liquidMixture::New
-        (
-            owner.mesh().objectRegistry::lookupObject<dictionary>
-            (
-                owner.carrierThermo().name()
-            )
-        )
-    ),
-    solids_
-    (
-        solidMixture::New
-        (
-            owner.mesh().objectRegistry::lookupObject<dictionary>
-            (
-                owner.carrierThermo().name()
-            )
-        )
-    ),
+    thermo_(owner.thermo()),
     phaseProps_
     (
         coeffDict_.lookup("phases"),
-        mcCarrierThermo_.species(),
-        liquids_().components(),
-        solids_().components()
+        thermo_.carrier().species(),
+        thermo_.liquids().components(),
+        thermo_.solids().components()
     )
 {}
 
@@ -100,24 +80,31 @@ const Foam::dictionary& Foam::CompositionModel<CloudType>::coeffDict() const
 
 
 template<class CloudType>
-const Foam::multiComponentMixture<typename CloudType::thermoType>&
-Foam::CompositionModel<CloudType>::mcCarrierThermo() const
+const Foam::SLGThermo& Foam::CompositionModel<CloudType>::thermo() const
 {
-    return mcCarrierThermo_;
+    return thermo_;
+}
+
+
+template<class CloudType>
+const Foam::basicMultiComponentMixture&
+Foam::CompositionModel<CloudType>::carrier() const
+{
+    return thermo_.carrier();
 }
 
 
 template<class CloudType>
 const Foam::liquidMixture& Foam::CompositionModel<CloudType>::liquids() const
 {
-    return liquids_();
+    return thermo_.liquids();
 }
 
 
 template<class CloudType>
 const Foam::solidMixture& Foam::CompositionModel<CloudType>::solids() const
 {
-    return solids_();
+    return thermo_.solids();
 }
 
 
@@ -137,8 +124,7 @@ Foam::label Foam::CompositionModel<CloudType>::nPhase() const
 
 
 template<class CloudType>
-const Foam::wordList&
-Foam::CompositionModel<CloudType>::phaseTypes() const
+const Foam::wordList& Foam::CompositionModel<CloudType>::phaseTypes() const
 {
     // if only 1 phase, return the constituent component names
     if (phaseProps_.size() == 1)
@@ -153,8 +139,7 @@ Foam::CompositionModel<CloudType>::phaseTypes() const
 
 
 template<class CloudType>
-const Foam::wordList&
-Foam::CompositionModel<CloudType>::stateLabels() const
+const Foam::wordList& Foam::CompositionModel<CloudType>::stateLabels() const
 {
     return phaseProps_.stateLabels();
 }
@@ -174,24 +159,22 @@ Foam::label Foam::CompositionModel<CloudType>::globalCarrierId
     const word& cmptName
 ) const
 {
-    forAll(mcCarrierThermo_.species(), i)
+    label id = thermo_.carrierId(cmptName);
+
+    if (id < 0)
     {
-        if (cmptName == mcCarrierThermo_.species()[i])
-        {
-            return i;
-        }
+        FatalErrorIn
+        (
+            "Foam::label Foam::CompositionModel<CloudType>::globalCarrierId"
+            "("
+                "const word&"
+            ") const"
+        )   << "Unable to determine global id for requested component "
+            << cmptName << ". Available components are " << nl
+            << thermo_.carrier().species() << abort(FatalError);
     }
 
-    FatalErrorIn
-    (
-        "Foam::label Foam::CompositionModel<CloudType>::globalCarrierId"
-        "("
-            "const word&"
-        ") const"
-    )   << "Unable to determine global id for requested component "
-        << cmptName << nl << abort(FatalError);
-
-    return -1;
+    return id;
 }
 
 
@@ -214,7 +197,7 @@ Foam::label Foam::CompositionModel<CloudType>::globalId
                 "const word&"
             ") const"
         )   << "Unable to determine global id for requested component "
-            << cmptName << nl << abort(FatalError);
+            << cmptName << abort(FatalError);
     }
 
     return id;
@@ -250,7 +233,7 @@ Foam::label Foam::CompositionModel<CloudType>::localId
                 "const word&"
             ") const"
         )   << "Unable to determine local id for component " << cmptName
-            << nl << abort(FatalError);
+            << abort(FatalError);
     }
 
     return id;
@@ -278,7 +261,7 @@ Foam::label Foam::CompositionModel<CloudType>::localToGlobalCarrierId
             ") const"
         )   << "Unable to determine global carrier id for phase "
             << phaseI << " with local id " << id
-            << nl << abort(FatalError);
+            << abort(FatalError);
     }
 
     return gid;
@@ -312,8 +295,8 @@ Foam::scalarField Foam::CompositionModel<CloudType>::X
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                WInv += Y[i]/mcCarrierThermo_.speciesData()[gid].W();
-                X[i] = Y[i]/mcCarrierThermo_.speciesData()[gid].W();
+                WInv += Y[i]/thermo_.carrier().W(gid);
+                X[i] = Y[i]/thermo_.carrier().W(gid);
             }
             break;
         }
@@ -322,8 +305,8 @@ Foam::scalarField Foam::CompositionModel<CloudType>::X
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                WInv += Y[i]/this->liquids().properties()[gid].W();
-                X[i] += Y[i]/this->liquids().properties()[gid].W();
+                WInv += Y[i]/thermo_.liquids().properties()[gid].W();
+                X[i] += Y[i]/thermo_.liquids().properties()[gid].W();
             }
             break;
         }
@@ -337,7 +320,7 @@ Foam::scalarField Foam::CompositionModel<CloudType>::X
                     "const scalarField&"
                 ") const"
             )   << "Only possible to convert gas and liquid mass fractions"
-                << nl << abort(FatalError);
+                << abort(FatalError);
         }
     }
 
@@ -363,7 +346,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::H
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HMixture += Y[i]*mcCarrierThermo_.speciesData()[gid].H(T);
+                HMixture += Y[i]*thermo_.carrier().H(gid, T);
             }
             break;
         }
@@ -372,7 +355,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::H
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HMixture += Y[i]*this->liquids().properties()[gid].h(p, T);
+                HMixture += Y[i]*thermo_.liquids().properties()[gid].h(p, T);
             }
             break;
         }
@@ -384,8 +367,8 @@ Foam::scalar Foam::CompositionModel<CloudType>::H
                 HMixture +=
                      Y[i]
                     *(
-                        this->solids().properties()[gid].Hf()
-                      + this->solids().properties()[gid].cp()*T
+                        thermo_.solids().properties()[gid].Hf()
+                      + thermo_.solids().properties()[gid].cp()*T
                      );
             }
             break;
@@ -401,7 +384,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::H
                 "    const scalar, "
                 "    const scalar"
                 ") const"
-            )   << "Unknown phase enumeration" << nl << abort(FatalError);
+            )   << "Unknown phase enumeration" << abort(FatalError);
         }
     }
 
@@ -427,7 +410,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hs
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HsMixture += Y[i]*mcCarrierThermo_.speciesData()[gid].Hs(T);
+                HsMixture += Y[i]*thermo_.carrier().Hs(gid, T);
             }
             break;
         }
@@ -439,8 +422,8 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hs
                 HsMixture +=
                     Y[i]
                    *(
-                       this->liquids().properties()[gid].h(p, T)
-                     - this->liquids().properties()[gid].h(p, 298.25)
+                       thermo_.liquids().properties()[gid].h(p, T)
+                     - thermo_.liquids().properties()[gid].h(p, 298.15)
                     );
             }
             break;
@@ -450,7 +433,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hs
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HsMixture += Y[i]*this->solids().properties()[gid].cp()*T;
+                HsMixture += Y[i]*thermo_.solids().properties()[gid].cp()*T;
             }
             break;
         }
@@ -465,7 +448,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hs
                 "    const scalar, "
                 "    const scalar"
                 ") const"
-            )   << "Unknown phase enumeration" << nl << abort(FatalError);
+            )   << "Unknown phase enumeration" << abort(FatalError);
         }
     }
 
@@ -491,7 +474,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hc
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HcMixture += Y[i]*mcCarrierThermo_.speciesData()[gid].Hc();
+                HcMixture += Y[i]*thermo_.carrier().Hc(gid);
             }
             break;
         }
@@ -501,7 +484,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hc
             {
                 label gid = props.globalIds()[i];
                 HcMixture +=
-                    Y[i]*this->liquids().properties()[gid].h(p, 298.15);
+                    Y[i]*thermo_.liquids().properties()[gid].h(p, 298.15);
             }
             break;
         }
@@ -510,7 +493,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hc
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                HcMixture += Y[i]*this->solids().properties()[gid].Hf();
+                HcMixture += Y[i]*thermo_.solids().properties()[gid].Hf();
             }
             break;
         }
@@ -525,7 +508,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::Hc
                 "    const scalar, "
                 "    const scalar"
                 ") const"
-            )   << "Unknown phase enumeration" << nl << abort(FatalError);
+            )   << "Unknown phase enumeration" << abort(FatalError);
         }
     }
 
@@ -551,7 +534,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::cp
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                cpMixture += Y[i]*mcCarrierThermo_.speciesData()[gid].Cp(T);
+                cpMixture += Y[i]*thermo_.carrier().Cp(gid, T);
             }
             break;
         }
@@ -560,7 +543,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::cp
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                cpMixture += Y[i]*this->liquids().properties()[gid].cp(p, T);
+                cpMixture += Y[i]*thermo_.liquids().properties()[gid].cp(p, T);
             }
             break;
         }
@@ -569,7 +552,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::cp
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                cpMixture += Y[i]*this->solids().properties()[gid].cp();
+                cpMixture += Y[i]*thermo_.solids().properties()[gid].cp();
             }
             break;
         }
@@ -584,7 +567,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::cp
                     "const scalar, "
                     "const scalar"
                 ") const"
-            )   << "Unknown phase enumeration" << nl << abort(FatalError);
+            )   << "Unknown phase enumeration" << abort(FatalError);
         }
     }
 
@@ -627,7 +610,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::L
             forAll(Y, i)
             {
                 label gid = props.globalIds()[i];
-                LMixture += Y[i]*this->liquids().properties()[gid].hl(p, T);
+                LMixture += Y[i]*thermo_.liquids().properties()[gid].hl(p, T);
             }
             break;
         }
@@ -659,7 +642,7 @@ Foam::scalar Foam::CompositionModel<CloudType>::L
                     "const scalar, "
                     "const scalar"
                 ") const"
-            )   << "Unknown phase enumeration" << nl << abort(FatalError);
+            )   << "Unknown phase enumeration" << abort(FatalError);
         }
     }
 

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

@@ -43,10 +43,7 @@ SourceFiles
 #include "runTimeSelectionTables.H"
 
 #include "PtrList.H"
-#include "multiComponentMixture.H"
-
-#include "liquidMixture.H"
-#include "solidMixture.H"
+#include "SLGThermo.H"
 
 #include "phasePropertiesList.H"
 
@@ -73,14 +70,8 @@ class CompositionModel
         //- The coefficients dictionary
         const dictionary& coeffDict_;
 
-        //- Reference to the multi-component carrier phase thermo
-        multiComponentMixture<typename CloudType::thermoType>& mcCarrierThermo_;
-
-        //- Global (additional) liquid properties data
-        autoPtr<liquidMixture> liquids_;
-
-        //- Global (additional) solid properties data
-        autoPtr<solidMixture> solids_;
+        //- Reference to the thermo database
+        const SLGThermo& thermo_;
 
         //- List of phase properties
         phasePropertiesList phaseProps_;
@@ -141,13 +132,15 @@ public:
             //- Return the coefficients dictionary
             const dictionary& coeffDict() const;
 
-            //- Return the carrier phase thermo package
-            const multiComponentMixture<typename CloudType::thermoType>&
-                mcCarrierThermo() const;
+            //- Return the thermo database
+            const SLGThermo& thermo() const;
 
 
             // Composition lists
 
+                //- Return the carrier components (wrapper function)
+                const basicMultiComponentMixture& carrier() const;
+
                 //- Return the global (additional) liquids
                 const liquidMixture& liquids() const;
 
@@ -197,11 +190,7 @@ public:
 
                 //- Return the list of phase phaseI volume fractions fractions
                 //  based on supplied mass fractions Y
-                scalarField X
-                (
-                    const label phaseI,
-                    const scalarField& Y
-                ) const;
+                scalarField X(const label phaseI, const scalarField& Y) const;
 
 
             // Mixture properties
@@ -293,18 +282,13 @@ public:
     );
 
 
-#define makeCompositionModelThermoType(SS, CloudType, ParcelType, ThermoType) \
+#define makeCompositionModelType(SS, CloudType, ParcelType)                   \
                                                                               \
-    defineNamedTemplateTypeNameAndDebug                                       \
-    (                                                                         \
-        SS<CloudType<ParcelType<ThermoType> > >,                              \
-        0                                                                     \
-    );                                                                        \
+    defineNamedTemplateTypeNameAndDebug(SS<CloudType<ParcelType> >, 0);       \
                                                                               \
-    CompositionModel<CloudType<ParcelType<ThermoType> > >::                   \
-        adddictionaryConstructorToTable                                       \
-            <SS<CloudType<ParcelType<ThermoType> > > >                        \
-            add##SS##CloudType##ParcelType##ThermoType##ConstructorToTable_;
+    CompositionModel<CloudType<ParcelType> >::                                \
+        adddictionaryConstructorToTable<SS<CloudType<ParcelType> > >          \
+            add##SS##CloudType##ParcelType##ConstructorToTable_;
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/intermediate/submodels/Reacting/CompositionModel/SingleMixtureFraction/SingleMixtureFraction.C

@@ -64,19 +64,19 @@ void Foam::SingleMixtureFraction<CloudType>::constructIds()
     {
         FatalErrorIn("Foam::SingleMixtureFraction<CloudType>::constructIds()")
             << "No gas phase found in phase list:" << nl
-            << this->phaseTypes() << nl << endl;
+            << this->phaseTypes() << exit(FatalError);
     }
     if (idLiquid_ < 0)
     {
         FatalErrorIn("Foam::SingleMixtureFraction<CloudType>::constructIds()")
             << "No liquid phase found in phase list:" << nl
-            << this->phaseTypes() << nl << endl;
+            << this->phaseTypes() << exit(FatalError);
     }
     if (idSolid_ < 0)
     {
         FatalErrorIn("Foam::SingleMixtureFraction<CloudType>::constructIds()")
             << "No solid phase found in phase list:" << nl
-            << this->phaseTypes() << nl << endl;
+            << this->phaseTypes() << exit(FatalError);
     }
 }
 
@@ -111,7 +111,7 @@ Foam::SingleMixtureFraction<CloudType>::SingleMixtureFraction
                 "CloudType&"
             ")"
         )   << "Incorrect numebr of phases: " << nl
-            << "    Please specify 1 gas, 1 liquid and 1 solid" << nl
+            << "    Please specify 1 gas, 1 liquid and 1 solid"
             << exit(FatalError);
     }
 
@@ -130,7 +130,7 @@ Foam::SingleMixtureFraction<CloudType>::SingleMixtureFraction
                 "CloudType&"
             ")"
         )   << "Sum of phases should be 1. Phase fractions:" << nl
-            << YMixture0_ << nl << exit(FatalError);
+            << YMixture0_ << exit(FatalError);
     }
 }