diff --git a/applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C b/applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
index 46c0171e5a..459eaa0cef 100644
--- a/applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
+++ b/applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
@@ -132,6 +132,7 @@ Usage
 #include "surfaceFields.H"
 #include "syncTools.H"
 #include "cyclicPolyPatch.H"
+#include "wedgePolyPatch.H"
 #include "nonuniformTransformCyclicPolyPatch.H"
 #include "extrudeModel.H"
 
@@ -951,6 +952,12 @@ int main(int argc, char *argv[])
     // Region
     const word shellRegionName(dict.lookup("region"));
     const wordList zoneNames(dict.lookup("faceZones"));
+    wordList zoneShadowNames(0);
+    if (dict.found("faceZonesShadow"))
+    {
+        dict.lookup("faceZonesShadow") >> zoneShadowNames;
+    }
+
     const Switch oneD(dict.lookup("oneD"));
     const Switch adaptMesh(dict.lookup("adaptMesh"));
 
@@ -1007,6 +1014,47 @@ int main(int argc, char *argv[])
         }
     }
 
+    labelList zoneShadowIDs;
+    if (zoneShadowNames.size())
+    {
+        zoneShadowIDs.setSize(zoneShadowNames.size());
+        forAll(zoneShadowNames, i)
+        {
+            zoneShadowIDs[i] = faceZones.findZoneID(zoneShadowNames[i]);
+            if (zoneShadowIDs[i] == -1)
+            {
+                FatalErrorIn(args.executable())
+                    << "Cannot find zone " << zoneShadowNames[i] << endl
+                    << "Valid zones are " << faceZones.names()
+                    << exit(FatalError);
+            }
+        }
+    }
+
+    label nShadowFaces = 0;
+    forAll(zoneShadowIDs, i)
+    {
+        nShadowFaces += faceZones[zoneShadowIDs[i]].size();
+    }
+
+    labelList extrudeMeshShadowFaces(nShadowFaces);
+    boolList zoneShadowFlipMap(nShadowFaces);
+    labelList zoneShadowID(nShadowFaces);
+
+    nShadowFaces = 0;
+    forAll(zoneShadowIDs, i)
+    {
+        const faceZone& fz = faceZones[zoneShadowIDs[i]];
+        forAll(fz, j)
+        {
+            extrudeMeshShadowFaces[nShadowFaces] = fz[j];
+            zoneShadowFlipMap[nShadowFaces] = fz.flipMap()[j];
+            zoneShadowID[nShadowFaces] = zoneShadowIDs[i];
+            nShadowFaces++;
+        }
+    }
+
+
 
     // Collect faces to extrude and per-face information
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1047,6 +1095,19 @@ int main(int argc, char *argv[])
         << nl
         << endl;
 
+     // Check nExtrudeFaces = nShadowFaces
+    if (zoneShadowNames.size())
+    {
+        if (nExtrudeFaces != nShadowFaces)
+        {
+            FatalErrorIn(args.executable())
+                << "Extruded faces " << nExtrudeFaces << endl
+                << "is different from shadow faces. " << nShadowFaces
+                << "This is not permitted " << endl
+                << exit(FatalError);
+        }
+    }
+
 
     // Determine corresponding mesh edges
     const labelList extrudeMeshEdges
@@ -1135,7 +1196,7 @@ int main(int argc, char *argv[])
                 << '\t' << patches[interRegionBottomPatch[i]].type()
                 << nl;
         }
-        else
+        else if (zoneShadowNames.size() == 0)
         {
             interRegionTopPatch[i] = addPatch<polyPatch>
             (
@@ -1159,6 +1220,31 @@ int main(int argc, char *argv[])
                 << '\t' << patches[interRegionBottomPatch[i]].type()
                 << nl;
         }
+        else if (zoneShadowNames.size() > 0) //patch using shadow face zones.
+        {
+            interRegionTopPatch[i] = addPatch<directMappedWallPolyPatch>
+            (
+                mesh,
+                zoneShadowNames[i] + "_top"
+            );
+            nCoupled++;
+            Info<< interRegionTopPatch[i]
+                << '\t' << patches[interRegionTopPatch[i]].name()
+                << '\t' << patches[interRegionTopPatch[i]].type()
+                << nl;
+
+            interRegionBottomPatch[i] = addPatch<directMappedWallPolyPatch>
+            (
+                mesh,
+                interName
+            );
+            nCoupled++;
+            Info<< interRegionBottomPatch[i]
+                << '\t' << patches[interRegionBottomPatch[i]].name()
+                << '\t' << patches[interRegionBottomPatch[i]].type()
+                << nl;
+        }
+
     }
     Info<< "Added " << nCoupled << " inter-region patches." << nl
         << endl;
@@ -1216,9 +1302,9 @@ int main(int argc, char *argv[])
         if (oneD)
         {
             // Reuse single empty patch.
-            word patchName = "oneDEmptPatch";
+            word patchName = "oneDWedgePatch";
 
-            zoneSidePatch[zoneI] = addPatch<emptyPolyPatch>
+            zoneSidePatch[zoneI] = addPatch<wedgePolyPatch>
             (
                 mesh,
                 patchName
@@ -1335,7 +1421,7 @@ int main(int argc, char *argv[])
 
         if (oneD)
         {
-            nonManifoldEdge[edgeI] = 1;
+            //nonManifoldEdge[edgeI] = 1; //To fill the space
             ePatches.setSize(eFaces.size());
             forAll(eFaces, i)
             {
@@ -1754,48 +1840,91 @@ int main(int argc, char *argv[])
             }
         }
 
-        // Add faces (using same points) to be in top patch
-        forAll(extrudeMeshFaces, zoneFaceI)
+        if (zoneShadowNames.size() > 0) //if there is a top faceZone specified
         {
-            label meshFaceI = extrudeMeshFaces[zoneFaceI];
-            bool flip = zoneFlipMap[zoneFaceI];
-            const face& f = mesh.faces()[meshFaceI];
-
-            if (!flip)
+            forAll(extrudeMeshFaces, zoneFaceI)
             {
-                if (mesh.isInternalFace(meshFaceI))
+                label meshFaceI = extrudeMeshShadowFaces[zoneFaceI];
+                label zoneI = zoneShadowID[zoneFaceI];
+                bool flip = zoneShadowFlipMap[zoneFaceI];
+                const face& f = mesh.faces()[meshFaceI];
+
+                if (!flip)
+                {
+                    meshMod.modifyFace
+                    (
+                        f,                          // modified face
+                        meshFaceI,                  // face being modified
+                        mesh.faceOwner()[meshFaceI],// owner
+                        -1,                         // neighbour
+                        false,                      // face flip
+                        extrudeTopPatchID[zoneFaceI],// patch for face
+                        zoneI,                      // zone for face
+                        flip                        // face flip in zone
+                    );
+                }
+                else if (mesh.isInternalFace(meshFaceI))
+                {
+                    meshMod.modifyFace
+                    (
+                        f.reverseFace(),                // modified face
+                        meshFaceI,                      // label modified face
+                        mesh.faceNeighbour()[meshFaceI],// owner
+                        -1,                             // neighbour
+                        true,                           // face flip
+                        extrudeTopPatchID[zoneFaceI],   // patch for face
+                        zoneI,                          // zone for face
+                        !flip                           // face flip in zone
+                    );
+                }
+            }
+
+        }
+        else
+        {
+            // Add faces (using same points) to be in top patch
+            forAll(extrudeMeshFaces, zoneFaceI)
+            {
+                label meshFaceI = extrudeMeshFaces[zoneFaceI];
+                bool flip = zoneFlipMap[zoneFaceI];
+                const face& f = mesh.faces()[meshFaceI];
+
+                if (!flip)
+                {
+                    if (mesh.isInternalFace(meshFaceI))
+                    {
+                        meshMod.addFace
+                        (
+                            f.reverseFace(),                // modified face
+                            mesh.faceNeighbour()[meshFaceI],// owner
+                            -1,                             // neighbour
+                            -1,                             // master point
+                            -1,                             // master edge
+                            meshFaceI,                      // master face
+                            true,                           // flip flux
+                            extrudeTopPatchID[zoneFaceI],   // patch for face
+                            -1,                             // zone for face
+                            false                           //face flip in zone
+                        );
+                    }
+                }
+                else
                 {
                     meshMod.addFace
                     (
-                        f.reverseFace(),                // modified face
-                        mesh.faceNeighbour()[meshFaceI],// owner
+                        f,                              // face
+                        mesh.faceOwner()[meshFaceI],    // owner
                         -1,                             // neighbour
                         -1,                             // master point
                         -1,                             // master edge
                         meshFaceI,                      // master face
-                        true,                           // flip flux
+                        false,                          // flip flux
                         extrudeTopPatchID[zoneFaceI],   // patch for face
                         -1,                             // zone for face
-                        false                           // face flip in zone
+                        false                           // zone flip
                     );
                 }
             }
-            else
-            {
-                meshMod.addFace
-                (
-                    f,                              // face
-                    mesh.faceOwner()[meshFaceI],    // owner
-                    -1,                             // neighbour
-                    -1,                             // master point
-                    -1,                             // master edge
-                    meshFaceI,                      // master face
-                    false,                          // flip flux
-                    extrudeTopPatchID[zoneFaceI],   // patch for face
-                    -1,                             // zone for face
-                    false                           // zone flip
-                );
-            }
         }
 
         // Change the mesh. Change points directly (no inflation).
diff --git a/applications/utilities/parallelProcessing/decomposePar/Make/files b/applications/utilities/parallelProcessing/decomposePar/Make/files
index 076ecd41bf..125f6b81e7 100644
--- a/applications/utilities/parallelProcessing/decomposePar/Make/files
+++ b/applications/utilities/parallelProcessing/decomposePar/Make/files
@@ -2,6 +2,7 @@ decomposePar.C
 domainDecomposition.C
 domainDecompositionMesh.C
 domainDecompositionDistribute.C
+dimFieldDecomposer.C
 fvFieldDecomposer.C
 pointFieldDecomposer.C
 lagrangianFieldDecomposer.C
diff --git a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
index 8c8b1dfc88..ea306917e5 100644
--- a/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
+++ b/applications/utilities/parallelProcessing/decomposePar/decomposePar.C
@@ -81,6 +81,7 @@ Usage
 #include "pointFields.H"
 
 #include "readFields.H"
+#include "dimFieldDecomposer.H"
 #include "fvFieldDecomposer.H"
 #include "pointFieldDecomposer.H"
 #include "lagrangianFieldDecomposer.H"
@@ -354,6 +355,25 @@ int main(int argc, char *argv[])
     readFields(mesh, objects, volTensorFields);
 
 
+    // Construct the dimensioned fields
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    PtrList<DimensionedField<scalar, volMesh> > dimScalarFields;
+    readFields(mesh, objects, dimScalarFields);
+
+    PtrList<DimensionedField<vector, volMesh> > dimVectorFields;
+    readFields(mesh, objects, dimVectorFields);
+
+    PtrList<DimensionedField<sphericalTensor, volMesh> >
+        dimSphericalTensorFields;
+    readFields(mesh, objects, dimSphericalTensorFields);
+
+    PtrList<DimensionedField<symmTensor, volMesh> > dimSymmTensorFields;
+    readFields(mesh, objects, dimSymmTensorFields);
+
+    PtrList<DimensionedField<tensor, volMesh> > dimTensorFields;
+    readFields(mesh, objects, dimTensorFields);
+
+
     // Construct the surface fields
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     PtrList<surfaceScalarField> surfaceScalarFields;
@@ -727,19 +747,6 @@ int main(int argc, char *argv[])
         );
 
         // FV fields
-        if
-        (
-            volScalarFields.size()
-         || volVectorFields.size()
-         || volSphericalTensorFields.size()
-         || volSymmTensorFields.size()
-         || volTensorFields.size()
-         || surfaceScalarFields.size()
-         || surfaceVectorFields.size()
-         || surfaceSphericalTensorFields.size()
-         || surfaceSymmTensorFields.size()
-         || surfaceTensorFields.size()
-        )
         {
             fvFieldDecomposer fieldDecomposer
             (
@@ -763,16 +770,25 @@ int main(int argc, char *argv[])
             fieldDecomposer.decomposeFields(surfaceTensorFields);
         }
 
+        // Dimensioned fields
+        {
+            dimFieldDecomposer fieldDecomposer
+            (
+                mesh,
+                procMesh,
+                faceProcAddressing,
+                cellProcAddressing
+            );
+
+            fieldDecomposer.decomposeFields(dimScalarFields);
+            fieldDecomposer.decomposeFields(dimVectorFields);
+            fieldDecomposer.decomposeFields(dimSphericalTensorFields);
+            fieldDecomposer.decomposeFields(dimSymmTensorFields);
+            fieldDecomposer.decomposeFields(dimTensorFields);
+        }
+
 
         // Point fields
-        if
-        (
-            pointScalarFields.size()
-         || pointVectorFields.size()
-         || pointSphericalTensorFields.size()
-         || pointSymmTensorFields.size()
-         || pointTensorFields.size()
-        )
         {
             labelIOList pointProcAddressing
             (
@@ -822,21 +838,6 @@ int main(int argc, char *argv[])
                 );
 
                 // Lagrangian fields
-                if
-                (
-                    lagrangianLabelFields[cloudI].size()
-                 || lagrangianLabelFieldFields[cloudI].size()
-                 || lagrangianScalarFields[cloudI].size()
-                 || lagrangianScalarFieldFields[cloudI].size()
-                 || lagrangianVectorFields[cloudI].size()
-                 || lagrangianVectorFieldFields[cloudI].size()
-                 || lagrangianSphericalTensorFields[cloudI].size()
-                 || lagrangianSphericalTensorFieldFields[cloudI].size()
-                 || lagrangianSymmTensorFields[cloudI].size()
-                 || lagrangianSymmTensorFieldFields[cloudI].size()
-                 || lagrangianTensorFields[cloudI].size()
-                 || lagrangianTensorFieldFields[cloudI].size()
-                )
                 {
                     fieldDecomposer.decomposeFields
                     (
diff --git a/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.C b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.C
new file mode 100644
index 0000000000..8c61e0920c
--- /dev/null
+++ b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.C
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "dimFieldDecomposer.H"
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::dimFieldDecomposer::dimFieldDecomposer
+(
+    const fvMesh& completeMesh,
+    const fvMesh& procMesh,
+    const labelList& faceAddressing,
+    const labelList& cellAddressing
+)
+:
+    completeMesh_(completeMesh),
+    procMesh_(procMesh),
+    faceAddressing_(faceAddressing),
+    cellAddressing_(cellAddressing)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::dimFieldDecomposer::~dimFieldDecomposer()
+{}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.H b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.H
new file mode 100644
index 0000000000..ba88e85c8d
--- /dev/null
+++ b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.H
@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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::dimFieldDecomposer
+
+Description
+    Dimensioned field decomposer.
+
+SourceFiles
+    dimFieldDecomposer.C
+    dimFieldDecomposerDecomposeFields.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dimFieldDecomposer_H
+#define dimFieldDecomposer_H
+
+#include "fvMesh.H"
+#include "fvPatchFieldMapper.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class IOobjectList;
+
+/*---------------------------------------------------------------------------*\
+                    Class fvFieldDecomposer Declaration
+\*---------------------------------------------------------------------------*/
+
+class dimFieldDecomposer
+{
+private:
+
+    // Private data
+
+        //- Reference to complete mesh
+        const fvMesh& completeMesh_;
+
+        //- Reference to processor mesh
+        const fvMesh& procMesh_;
+
+        //- Reference to face addressing
+        const labelList& faceAddressing_;
+
+        //- Reference to cell addressing
+        const labelList& cellAddressing_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        dimFieldDecomposer(const dimFieldDecomposer&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const dimFieldDecomposer&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        dimFieldDecomposer
+        (
+            const fvMesh& completeMesh,
+            const fvMesh& procMesh,
+            const labelList& faceAddressing,
+            const labelList& cellAddressing
+        );
+
+
+    //- Destructor
+    ~dimFieldDecomposer();
+
+
+    // Member Functions
+
+        //- Decompose field
+        template<class Type>
+        tmp<DimensionedField<Type, volMesh> > decomposeField
+        (
+            const DimensionedField<Type, volMesh>& field
+        ) const;
+
+
+        //- Decompose llist of fields
+        template<class GeoField>
+        void decomposeFields(const PtrList<GeoField>& fields) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "dimFieldDecomposerDecomposeFields.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposerDecomposeFields.C b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposerDecomposeFields.C
new file mode 100644
index 0000000000..2ca8088103
--- /dev/null
+++ b/applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposerDecomposeFields.C
@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "dimFieldDecomposer.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh> >
+Foam::dimFieldDecomposer::decomposeField
+(
+    const DimensionedField<Type, volMesh>& field
+) const
+{
+    // Create and map the internal field values
+    Field<Type> mappedField(field, cellAddressing_);
+
+    // Create the field for the processor
+    return tmp<DimensionedField<Type, volMesh> >
+    (
+        new DimensionedField<Type, volMesh>
+        (
+            IOobject
+            (
+                field.name(),
+                procMesh_.time().timeName(),
+                procMesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            procMesh_,
+            field.dimensions(),
+            mappedField
+        )
+    );
+}
+
+
+template<class GeoField>
+void Foam::dimFieldDecomposer::decomposeFields
+(
+    const PtrList<GeoField>& fields
+) const
+{
+    forAll(fields, fieldI)
+    {
+        decomposeField(fields[fieldI])().write();
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/parallelProcessing/decomposePar/readFields.C b/applications/utilities/parallelProcessing/decomposePar/readFields.C
index f72d0a6ac5..5de523e3c2 100644
--- a/applications/utilities/parallelProcessing/decomposePar/readFields.C
+++ b/applications/utilities/parallelProcessing/decomposePar/readFields.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,7 +35,7 @@ void Foam::readFields
     PtrList<GeoField>& fields
 )
 {
-    // Search list of objects for volScalarFields
+    // Search list of objects for fields of type GeomField
     IOobjectList fieldObjects(objects.lookupClass(GeoField::typeName));
 
     // Remove the cellDist field
@@ -45,7 +45,7 @@ void Foam::readFields
         fieldObjects.erase(celDistIter);
     }
 
-    // Construct the vol scalar fields
+    // Construct the fields
     fields.setSize(fieldObjects.size());
 
     label fieldI = 0;
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 817381be61..87ba99409d 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -29,6 +29,7 @@ derivedFvPatches = $(fvPatches)/derived
 $(derivedFvPatches)/wall/wallFvPatch.C
 $(derivedFvPatches)/directMapped/directMappedFvPatch.C
 $(derivedFvPatches)/directMapped/directMappedWallFvPatch.C
+$(derivedFvPatches)/directMapped/directMappedVariableThicknessWallFvPatch.C
 
 wallDist = fvMesh/wallDist
 $(wallDist)/wallPointYPlus/wallPointYPlus.C
diff --git a/src/finiteVolume/Make/options b/src/finiteVolume/Make/options
index b91061399e..afa13b620e 100644
--- a/src/finiteVolume/Make/options
+++ b/src/finiteVolume/Make/options
@@ -1,8 +1,10 @@
 EXE_INC = \
     -I$(LIB_SRC)/triSurface/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude
 
 LIB_LIBS = \
     -lOpenFOAM \
     -ltriSurface \
-    -lmeshTools
+    -lmeshTools \
+    -lregionModels
diff --git a/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.C b/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.C
new file mode 100644
index 0000000000..2e9319df76
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.C
@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "directMappedVariableThicknessWallFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "regionModel1D.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(directMappedVariableThicknessWallFvPatch, 0);
+    addToRunTimeSelectionTable
+    (
+        fvPatch,
+        directMappedVariableThicknessWallFvPatch,
+        polyPatch
+    );
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::directMappedVariableThicknessWallFvPatch::
+makeDeltaCoeffs(scalarField& dc) const
+{
+    const directMappedVariableThicknessWallPolyPatch& pp =
+        refCast<const directMappedVariableThicknessWallPolyPatch>
+        (
+            patch()
+        );
+
+    const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
+    (
+        patch()
+    );
+
+    const polyMesh& nbrMesh = mpp.sampleMesh();
+
+    typedef regionModels::regionModel1D modelType;
+
+    const modelType& region1D =
+        nbrMesh.objectRegistry::lookupObject<modelType>
+        (
+            "thermoBaffleProperties"
+        );
+
+    dc = 2.0/(pp.thickness()/region1D.nLayers());
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.H b/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.H
new file mode 100644
index 0000000000..69e8ad06a1
--- /dev/null
+++ b/src/finiteVolume/fvMesh/fvPatches/derived/directMapped/directMappedVariableThicknessWallFvPatch.H
@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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::directMappedVariableThicknessWallFvPatch
+
+Description
+    Take thickness field and number of layers and returns deltaCoeffs
+    as 2.0/thickness/nLayers.
+    To be used with 1D thermo baffle.
+
+SourceFiles
+    directMappedVariableThicknessWallFvPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef directMappedWallFvPatch_H
+#define directMappedWallFvPatch_H
+
+#include "wallFvPatch.H"
+#include "directMappedVariableThicknessWallPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+        Class directMappedVariableThicknessWallFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class directMappedVariableThicknessWallFvPatch
+:
+    public wallFvPatch
+{
+
+protected:
+
+    // Protected Member Functions
+
+        //- Read neighbour cell distances from dictionary
+        void makeDeltaCoeffs(scalarField& dc) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName(directMappedVariableThicknessWallPolyPatch::typeName_());
+
+
+    // Constructors
+
+        //- Construct from components
+        directMappedVariableThicknessWallFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        )
+        :
+            wallFvPatch(patch, bm)
+        {}
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C
index cbdf299df7..cfbd376d9a 100644
--- a/src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C
+++ b/src/lagrangian/intermediate/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C
@@ -76,14 +76,16 @@ void Foam::FacePostProcessing<CloudType>::makeLogFile
 
         if (Pstream::master())
         {
+            const fileName logDir = outputDir_/this->owner().time().timeName();
+
             // Create directory if does not exist
-            mkDir(outputDir_);
+            mkDir(logDir);
 
             // Open new file at start up
             outputFilePtr_.set
             (
                 zoneI,
-                new OFstream(outputDir_/(type() + '_' + zoneName + ".dat"))
+                new OFstream(logDir/(type() + '_' + zoneName + ".dat"))
             );
 
             outputFilePtr_[zoneI]
@@ -164,21 +166,6 @@ void Foam::FacePostProcessing<CloudType>::write()
 
     if (surfaceFormat_ != "none")
     {
-        fileName outputDir = mesh.time().path();
-
-        if (Pstream::parRun())
-        {
-            // Put in undecomposed case (Note: gives problems for
-            // distributed data running)
-            outputDir =
-                outputDir/".."/"postProcessing"/cloud::prefix/time.timeName();
-        }
-        else
-        {
-            outputDir =
-                outputDir/"postProcessing"/cloud::prefix/time.timeName();
-        }
-
         forAll(faceZoneIDs_, zoneI)
         {
             const faceZone& fZone = fzm[faceZoneIDs_[zoneI]];
@@ -233,7 +220,7 @@ void Foam::FacePostProcessing<CloudType>::write()
 
                 writer->write
                 (
-                    outputDir,
+                    outputDir_/time.timeName(),
                     fZone.name(),
                     allPoints,
                     allFaces,
@@ -244,7 +231,7 @@ void Foam::FacePostProcessing<CloudType>::write()
 
                 writer->write
                 (
-                    outputDir,
+                    outputDir_/time.timeName(),
                     fZone.name(),
                     allPoints,
                     allFaces,
@@ -308,14 +295,12 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
         // Put in undecomposed case (Note: gives problems for
         // distributed data running)
         outputDir_ =
-            outputDir_/".."/"postProcessing"/cloud::prefix/
-            owner.name()/owner.mesh().time().timeName();
+            outputDir_/".."/"postProcessing"/cloud::prefix/owner.name();
     }
     else
     {
         outputDir_ =
-            outputDir_/"postProcessing"/cloud::prefix/
-            owner.name()/owner.mesh().time().timeName();
+            outputDir_/"postProcessing"/cloud::prefix/owner.name();
     }
 
     DynamicList<label> zoneIDs;
@@ -333,7 +318,7 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
             mass_[i].setSize(nFaces, 0.0);
             massTotal_[i].setSize(nFaces, 0.0);
             massFlux_[i].setSize(nFaces, 0.0);
-            Info<< "        " << zoneName << " faces: " << nFaces;
+            Info<< "        " << zoneName << " faces: " << nFaces << nl;
 
             scalar totArea = 0.0;
             forAll(fz, j)
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
index 1339545c23..e8844a5261 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
+++ b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.C
@@ -30,6 +30,82 @@ License
 
 using namespace Foam::constant;
 
+// * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::ConeNozzleInjection<CloudType>::setInjectionMethod()
+{
+    word injectionMethodType = this->coeffDict().lookup("injectionMethod");
+    if (injectionMethodType == "disc")
+    {
+        injectionMethod_ = imDisc;
+    }
+    else if (injectionMethodType == "point")
+    {
+        injectionMethod_ = imPoint;
+
+        // Set/cache the injector cell
+        this->findCellAtPosition
+        (
+            injectorCell_,
+            tetFaceI_,
+            tetPtI_,
+            position_,
+            false
+        );
+    }
+    else
+    {
+        FatalErrorIn("Foam::InjectionModel<CloudType>::setInjectionMethod()")
+            << "injectionMethod must be either 'point' or 'disc'"
+            << exit(FatalError);
+    }
+}
+
+
+template<class CloudType>
+void Foam::ConeNozzleInjection<CloudType>::setFlowType()
+{
+    word flowType = this->coeffDict().lookup("flowType");
+    if (flowType == "constantVelocity")
+    {
+        this->coeffDict().lookup("UMag") >> UMag_;
+        flowType_ = ftConstantVelocity;
+    }
+    else if (flowType == "pressureDrivenVelocity")
+    {
+        Pinj_.reset
+        (
+            DataEntry<scalar>::New
+            (
+                "Pinj",
+                this->coeffDict()
+            ).ptr()
+        );
+        flowType_ = ftPressureDrivenVelocity;
+    }
+    else if (flowType == "flowRateAndDischarge")
+    {
+        Cd_.reset
+        (
+            DataEntry<scalar>::New
+            (
+                "Cd",
+                this->coeffDict()
+            ).ptr()
+        );
+        flowType_ = ftFlowRateAndDischarge;
+    }
+    else
+    {
+        FatalErrorIn("Foam::InjectionModel<CloudType>::setFlowType()")
+            << "flowType must be either 'constantVelocity', "
+            <<"'pressureDrivenVelocity' or 'flowRateAndDischarge'"
+            << exit(FatalError);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -41,14 +117,9 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
 :
     InjectionModel<CloudType>(dict, owner, typeName),
     injectionMethod_(imPoint),
-    outerNozzleDiameter_
-    (
-        readScalar(this->coeffDict().lookup("outerNozzleDiameter"))
-    ),
-    innerNozzleDiameter_
-    (
-        readScalar(this->coeffDict().lookup("innerNozzleDiameter"))
-    ),
+    flowType_(ftConstantVelocity),
+    outerDiameter_(readScalar(this->coeffDict().lookup("outerDiameter"))),
+    innerDiameter_(readScalar(this->coeffDict().lookup("innerDiameter"))),
     duration_(readScalar(this->coeffDict().lookup("duration"))),
     position_(this->coeffDict().lookup("position")),
     injectorCell_(-1),
@@ -67,14 +138,6 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
             this->coeffDict()
         )
     ),
-    Cd_
-    (
-        DataEntry<scalar>::New
-        (
-            "Cd",
-            this->coeffDict()
-        )
-    ),
     thetaInner_
     (
         DataEntry<scalar>::New
@@ -101,9 +164,13 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
     ),
     tanVec1_(vector::zero),
     tanVec2_(vector::zero),
-    normal_(vector::zero)
+    normal_(vector::zero),
+
+    UMag_(0.0),
+    Cd_(NULL),
+    Pinj_(NULL)
 {
-    if (innerNozzleDiameter_ >= outerNozzleDiameter_)
+    if (innerDiameter_ >= outerDiameter_)
     {
         FatalErrorIn
         (
@@ -116,38 +183,9 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
          << exit(FatalError);
     }
 
-    word injectionMethodType = this->coeffDict().lookup("injectionMethod");
+    setInjectionMethod();
 
-    if (injectionMethodType == "disc")
-    {
-        injectionMethod_ = imDisc;
-    }
-    else if (injectionMethodType == "point")
-    {
-        injectionMethod_ = imPoint;
-
-        // Set/cache the injector cell
-        this->findCellAtPosition
-        (
-            injectorCell_,
-            tetFaceI_,
-            tetPtI_,
-            position_,
-            false
-        );
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "Foam::InjectionModel<CloudType>::InjectionModel"
-            "("
-                "const dictionary&, "
-                "CloudType&"
-            ")"
-        )<< "injectionMethod must be either 'point' or 'disc'" << nl
-         << exit(FatalError);
-    }
+    setFlowType();
 
     cachedRandom& rndGen = this->owner().rndGen();
 
@@ -182,21 +220,23 @@ Foam::ConeNozzleInjection<CloudType>::ConeNozzleInjection
 :
     InjectionModel<CloudType>(im),
     injectionMethod_(im.injectionMethod_),
-    outerNozzleDiameter_(im.outerNozzleDiameter_),
-    innerNozzleDiameter_(im.innerNozzleDiameter_),
+    outerDiameter_(im.outerDiameter_),
+    innerDiameter_(im.innerDiameter_),
     duration_(im.duration_),
     position_(im.position_),
     injectorCell_(im.injectorCell_),
     direction_(im.direction_),
     parcelsPerSecond_(im.parcelsPerSecond_),
     volumeFlowRate_(im.volumeFlowRate_().clone().ptr()),
-    Cd_(im.Cd_().clone().ptr()),
     thetaInner_(im.thetaInner_().clone().ptr()),
     thetaOuter_(im.thetaOuter_().clone().ptr()),
     sizeDistribution_(im.sizeDistribution_().clone().ptr()),
     tanVec1_(im.tanVec1_),
     tanVec2_(im.tanVec1_),
-    normal_(im.normal_)
+    normal_(im.normal_),
+    UMag_(im.UMag_),
+    Cd_(im.Cd_().clone().ptr()),
+    Pinj_(im.Pinj_().clone().ptr())
 {}
 
 
@@ -283,8 +323,8 @@ void Foam::ConeNozzleInjection<CloudType>::setPositionAndCell
         case imDisc:
         {
             scalar frac = rndGen.sample01<scalar>();
-            scalar dr = outerNozzleDiameter_ - innerNozzleDiameter_;
-            scalar r = 0.5*(innerNozzleDiameter_ + frac*dr);
+            scalar dr = outerDiameter_ - innerDiameter_;
+            scalar r = 0.5*(innerDiameter_ + frac*dr);
             position = position_ + r*normal_;
 
             this->findCellAtPosition
@@ -344,13 +384,38 @@ void Foam::ConeNozzleInjection<CloudType>::setProperties
     dirVec += normal;
     dirVec /= mag(dirVec);
 
-    scalar Ao = 0.25*mathematical::pi*outerNozzleDiameter_*outerNozzleDiameter_;
-    scalar Ai = 0.25*mathematical::pi*innerNozzleDiameter_*innerNozzleDiameter_;
-    scalar massFlowRate =
-        this->massTotal()*volumeFlowRate_().value(t)/this->volumeTotal();
+    switch (flowType_)
+    {
+        case ftConstantVelocity:
+        {
+            parcel.U() = UMag_*dirVec;
+            break;
+        }
+        case ftPressureDrivenVelocity:
+        {
+            scalar pAmbient = this->owner().pAmbient();
+            scalar rho = parcel.rho();
+            scalar UMag = ::sqrt(2.0*(Pinj_().value(t) - pAmbient)/rho);
+            parcel.U() = UMag*dirVec;
+            break;
+        }
+        case ftFlowRateAndDischarge:
+        {
+            scalar Ao = 0.25*mathematical::pi*outerDiameter_*outerDiameter_;
+            scalar Ai = 0.25*mathematical::pi*innerDiameter_*innerDiameter_;
+            scalar massFlowRate =
+                this->massTotal()
+               *volumeFlowRate_().value(t)
+               /this->volumeTotal();
 
-    scalar Umag = massFlowRate/(parcel.rho()*Cd_().value(t)*(Ao - Ai));
-    parcel.U() = Umag*dirVec;
+            scalar Umag = massFlowRate/(parcel.rho()*Cd_().value(t)*(Ao - Ai));
+            parcel.U() = Umag*dirVec;
+            break;
+        }
+        default:
+        {
+        }
+    }
 
     // set particle diameter
     parcel.d() = sizeDistribution_->sample();
diff --git a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H
index d5e9a6fc7f..46f876acf8 100644
--- a/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H
+++ b/src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/ConeNozzleInjection/ConeNozzleInjection.H
@@ -32,16 +32,18 @@ Description
       - injector position
       - direction (along injection axis)
       - parcel flow rate
-      - discharge coefficient, Cd
       - inner and outer cone angles
 
     - Parcel diameters obtained by size distribution model
 
     - Parcel velocity is calculated as:
 
-        U = V_dot/(A * Cd), where V_dot is the volume flow rate
-
-    Based on the old 'unitInjection' model
+        - Constant velocity
+            U = <specified by user>
+        - Pressure driven velocity
+            U = sqrt(2*(Pinj - Pamb)/rho)
+        - Flow rate and discharge
+            U = V_dot/(A*Cd)
 
 SourceFiles
     ConeNozzleInjection.C
@@ -83,19 +85,30 @@ public:
         imDisc
     };
 
+    //- Flow type enumeration
+    enum flowType
+    {
+        ftConstantVelocity,
+        ftPressureDrivenVelocity,
+        ftFlowRateAndDischarge
+    };
+
 
 private:
 
     // Private data
 
-        //- point/disc injection method
+        //- Point/disc injection method
         injectionMethod injectionMethod_;
 
+        //- Flow type
+        flowType flowType_;
+
         //- Outer nozzle diameter [m]
-        const scalar outerNozzleDiameter_;
+        const scalar outerDiameter_;
 
         //- Inner nozzle diameter [m]
-        const scalar innerNozzleDiameter_;
+        const scalar innerDiameter_;
 
         //- Injection duration [s]
         const scalar duration_;
@@ -121,9 +134,6 @@ private:
         //- Volume flow rate of parcels to introduce relative to SOI [m^3/s]
         const autoPtr<DataEntry<scalar> > volumeFlowRate_;
 
-        //- Discharge coefficient, relative to SOI [m/s]
-        const autoPtr<DataEntry<scalar> > Cd_;
-
         //- Inner cone angle relative to SOI [deg]
         const autoPtr<DataEntry<scalar> > thetaInner_;
 
@@ -146,6 +156,27 @@ private:
             vector normal_;
 
 
+        // Velocity model coefficients
+
+            //- Constant velocity [m/s]
+            scalar UMag_;
+
+            //- Discharge coefficient, relative to SOI [m/s]
+            autoPtr<DataEntry<scalar> > Cd_;
+
+            //- Injection pressure [Pa]
+            autoPtr<DataEntry<scalar> > Pinj_;
+
+
+    // Private Member Functions
+
+        //- Set the injection type
+        void setInjectionMethod();
+
+        //- Set the injection flow type
+        void setFlowType();
+
+
 public:
 
     //- Runtime type information
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index f52dedbf61..abf52704b1 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -158,7 +158,10 @@ twoDPointCorrector/twoDPointCorrector.C
 directMapped/directMappedPolyPatch/directMappedPatchBase.C
 directMapped/directMappedPolyPatch/directMappedPolyPatch.C
 directMapped/directMappedPolyPatch/directMappedWallPolyPatch.C
+directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.C
 directMapped/directMappedPointPatch/directMappedPointPatch.C
 directMapped/directMappedPointPatch/directMappedWallPointPatch.C
 
+
+
 LIB = $(FOAM_LIBBIN)/libmeshTools
diff --git a/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.C b/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.C
new file mode 100644
index 0000000000..15764e2a97
--- /dev/null
+++ b/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.C
@@ -0,0 +1,178 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "directMappedVariableThicknessWallPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(directMappedVariableThicknessWallPolyPatch, 0);
+
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        directMappedVariableThicknessWallPolyPatch,
+        word
+    );
+
+    addToRunTimeSelectionTable
+    (
+        polyPatch,
+        directMappedVariableThicknessWallPolyPatch,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * * * * //
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    directMappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const directMappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vectorField& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    directMappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const word& sampleRegion,
+    const directMappedPatchBase::sampleMode mode,
+    const word& samplePatch,
+    const vector& offset,
+    const polyBoundaryMesh& bm
+)
+:
+    directMappedWallPolyPatch(name, size, start, index, bm),
+    thickness_(size)
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    directMappedWallPolyPatch(name, dict, index, bm),
+    thickness_(scalarField("thickness", dict, this->size()))
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const directMappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm
+)
+:
+    directMappedWallPolyPatch(pp, bm),
+    thickness_(pp.thickness_)
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const directMappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const label newSize,
+    const label newStart
+)
+:
+    directMappedWallPolyPatch(pp, bm, index, newSize, newStart),
+    thickness_(newSize)
+{}
+
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+directMappedVariableThicknessWallPolyPatch
+(
+    const directMappedVariableThicknessWallPolyPatch& pp,
+    const polyBoundaryMesh& bm,
+    const label index,
+    const labelUList& mapAddressing,
+    const label newStart
+)
+:
+    directMappedWallPolyPatch(pp, bm, index, mapAddressing, newStart),
+    thickness_(pp.size())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::directMappedVariableThicknessWallPolyPatch::
+~directMappedVariableThicknessWallPolyPatch()
+{
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::directMappedVariableThicknessWallPolyPatch::
+write(Foam::Ostream& os) const
+{
+    os.writeKeyword("thickness") << thickness_ << token::END_STATEMENT << nl;
+}
+
+// ************************************************************************* //
diff --git a/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.H b/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.H
new file mode 100644
index 0000000000..f8f063eb78
--- /dev/null
+++ b/src/meshTools/directMapped/directMappedPolyPatch/directMappedVariableThicknessWallPolyPatch.H
@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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::directMappedVariableThicknessWallPolyPatch
+
+Description
+    Foam::directMappedVariableThicknessWallPolyPatch
+
+SourceFiles
+    directMappedVariableThicknessWallPolyPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef directMappedVariableThicknessWallPolyPatch_H
+#define directMappedVariableThicknessWallPolyPatch_H
+
+#include "wallPolyPatch.H"
+#include "directMappedWallPolyPatch.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+        Class directMappedVariableThicknessWallPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class directMappedVariableThicknessWallPolyPatch
+:
+    public directMappedWallPolyPatch
+{
+
+    // Private data
+
+        //- Thickness
+        scalarList thickness_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("directMappedWallVariableThickness");
+
+
+    // Constructors
+
+        //- Construct from components
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const directMappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vectorField& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from components. Uniform offset.
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const word& sampleRegion,
+            const directMappedPatchBase::sampleMode mode,
+            const word& samplePatch,
+            const vector& offset,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct from dictionary
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const directMappedVariableThicknessWallPolyPatch&,
+            const polyBoundaryMesh&
+        );
+
+        //- Construct given the original patch and resetting the
+        //  face list and boundary mesh information
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const directMappedVariableThicknessWallPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const label newSize,
+            const label newStart
+        );
+
+        //- Construct given the original patch and a map
+        directMappedVariableThicknessWallPolyPatch
+        (
+            const directMappedVariableThicknessWallPolyPatch& pp,
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        );
+
+        //- Construct and return a clone, resetting the boundary mesh
+        virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new directMappedVariableThicknessWallPolyPatch(*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 directMappedVariableThicknessWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    newSize,
+                    newStart
+                )
+            );
+        }
+
+        //- Construct and return a clone, resetting the face list
+        //  and boundary mesh
+        virtual autoPtr<polyPatch> clone
+        (
+            const polyBoundaryMesh& bm,
+            const label index,
+            const labelUList& mapAddressing,
+            const label newStart
+        ) const
+        {
+            return autoPtr<polyPatch>
+            (
+                new directMappedVariableThicknessWallPolyPatch
+                (
+                    *this,
+                    bm,
+                    index,
+                    mapAddressing,
+                    newStart
+                )
+            );
+        }
+
+
+    //- Destructor
+    virtual ~directMappedVariableThicknessWallPolyPatch();
+
+
+    // Member functions
+
+        //- Return non const thickness
+        scalarList& thickness()
+        {
+            return thickness_;
+        }
+
+
+        //- Return const thickness
+        const scalarList& thickness() const
+        {
+            return thickness_;
+        }
+
+
+        //- Write the polyPatch data as a dictionary
+        void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/Allwmake b/src/regionModels/Allwmake
index b8b7bce119..86638a3ff3 100755
--- a/src/regionModels/Allwmake
+++ b/src/regionModels/Allwmake
@@ -6,6 +6,7 @@ set -x
 wmake $makeType regionModel
 #wmake $makeType pyrolysisModels
 wmake $makeType surfaceFilmModels
+wmake $makeType thermoBaffleModels
 #wmake $makeType regionCoupling
 
 
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/contactAngleForce/contactAngleForce.C b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/contactAngleForce/contactAngleForce.C
index 5604859dee..21d2e63d28 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/contactAngleForce/contactAngleForce.C
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/contactAngleForce/contactAngleForce.C
@@ -27,6 +27,7 @@ License
 #include "addToRunTimeSelectionTable.H"
 #include "fvcGrad.H"
 #include "unitConversion.H"
+#include "fvPatchField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -109,7 +110,8 @@ tmp<fvVectorMatrix> contactAngleForce::correct(volVectorField& U)
     );
     volVectorField gradAlpha(fvc::grad(alpha));
 
-    scalarField nHits(force.size(), 0.0);
+
+    scalarField nHits(owner_.regionMesh().nCells(), 0.0);
 
     forAll(nbr, faceI)
     {
@@ -129,6 +131,7 @@ tmp<fvVectorMatrix> contactAngleForce::correct(volVectorField& U)
         if (cellI != -1)
         {
 //            const scalar dx = Foam::sqrt(magSf[cellI]);
+            // bit of a cheat, but ok for regular meshes
             const scalar dx = owner_.regionMesh().deltaCoeffs()[faceI];
             const vector n =
                 gradAlpha[cellI]/(mag(gradAlpha[cellI]) + ROOTVSMALL);
@@ -138,8 +141,29 @@ tmp<fvVectorMatrix> contactAngleForce::correct(volVectorField& U)
         }
     }
 
-    nHits = max(nHits, 1.0);
-    force /= (nHits*magSf);
+    forAll(delta.boundaryField(), patchI)
+    {
+        const fvPatchField<scalar>& df = delta.boundaryField()[patchI];
+        const scalarField& dx = df.patch().deltaCoeffs();
+        const labelUList& faceCells = df.patch().faceCells();
+
+        forAll(df, faceI)
+        {
+            label cellO = faceCells[faceI];
+
+            if ((delta[cellO] > deltaWet_) && (df[faceI] < deltaWet_))
+            {
+                const vector n =
+                    gradAlpha[cellO]/(mag(gradAlpha[cellO]) + ROOTVSMALL);
+                scalar theta = cos(degToRad(distribution_->sample()));
+                force[cellO] += Ccf_*n*sigma[cellO]*(1.0 - theta)/dx[faceI];
+                nHits[cellO]++;
+            }
+        }
+    }
+
+    force /= (max(nHits, 1.0)*magSf);
+    tForce().correctBoundaryConditions();
 
     if (owner_.regionMesh().time().outputTime())
     {
diff --git a/src/regionModels/thermoBaffleModels/Make/files b/src/regionModels/thermoBaffleModels/Make/files
new file mode 100644
index 0000000000..1a0352a4bf
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/Make/files
@@ -0,0 +1,7 @@
+thermoBaffleModel/thermoBaffleModel.C
+thermoBaffleModel/thermoBaffleModelNew.C
+thermoBaffle2D/thermoBaffle2D.C
+noThermo/noThermo.C
+
+
+LIB = $(FOAM_LIBBIN)/libthermoBaffleModels
diff --git a/src/regionModels/thermoBaffleModels/Make/options b/src/regionModels/thermoBaffleModels/Make/options
new file mode 100644
index 0000000000..7328b5d856
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/Make/options
@@ -0,0 +1,18 @@
+EXE_INC = \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/solid/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel/lnInclude
+
+
+EXE_LIBS = \
+    -lregionModels \
+    -lbasicSolidThermo \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lOpenFOAM \
+    -lsolid
diff --git a/src/regionModels/thermoBaffleModels/noThermo/noThermo.C b/src/regionModels/thermoBaffleModels/noThermo/noThermo.C
new file mode 100644
index 0000000000..6f89110f5e
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/noThermo/noThermo.C
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "noThermo.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(noThermo, 0);
+addToRunTimeSelectionTable(thermoBaffleModel, noThermo, mesh);
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+bool noThermo::read()
+{
+    return regionModel1D::read();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+noThermo::noThermo(const word& modelType, const fvMesh& mesh)
+:
+    thermoBaffleModel(mesh)
+{}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+noThermo::~noThermo()
+{}
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void noThermo::preEvolveRegion()
+{
+}
+
+
+void noThermo::evolveRegion()
+{
+}
+
+const tmp<volScalarField> noThermo::Cp() const
+{
+    FatalErrorIn("const tmp<volScalarField>& noThermo::Cp() const")
+        << "Cp field not available for " << type() << abort(FatalError);
+
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "noThermo::Cp",
+                time().timeName(),
+                primaryMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            primaryMesh(),
+            dimensionedScalar("zero", dimEnergy/dimVolume/dimTime, 0.0)
+        )
+    );
+}
+
+const volScalarField& noThermo::kappa() const
+{
+    FatalErrorIn("const volScalarField& noThermo::kappa() const")
+        << "kappa field not available for " << type() << abort(FatalError);
+    return volScalarField::null();
+}
+
+const volScalarField& noThermo::rho() const
+{
+    FatalErrorIn("const volScalarField& noThermo::rho() const")
+        << "rho field not available for " << type() << abort(FatalError);
+    return volScalarField::null();
+}
+
+const volScalarField& noThermo::K() const
+{
+   FatalErrorIn("const volScalarField& noThermo::K() const")
+        << "K field not available for " << type() << abort(FatalError);
+    return volScalarField::null();
+}
+
+const volScalarField& noThermo::T() const
+{
+    FatalErrorIn("const volScalarField& noThermo::T() const")
+        << "T field not available for " << type() << abort(FatalError);
+    return volScalarField::null();
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/noThermo/noThermo.H b/src/regionModels/thermoBaffleModels/noThermo/noThermo.H
new file mode 100644
index 0000000000..387241cca4
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/noThermo/noThermo.H
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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::noThermo
+
+Description
+    Dummy surface pyrolysis model for 'none'
+
+SourceFiles
+    noThermo.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef noThermo_H
+#define noThermo_H
+
+#include "thermoBaffleModel.H"
+#include "volFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class noThermo Declaration
+\*---------------------------------------------------------------------------*/
+
+class noThermo
+:
+    public thermoBaffleModel
+{
+private:
+
+    // Private member functions
+
+        //- Disallow default bitwise copy construct
+        noThermo(const noThermo&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const noThermo&);
+
+
+protected:
+
+    // Protected member functions
+
+        //- Read control parameters from dictionary
+        virtual bool read();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("none");
+
+
+    // Constructors
+
+        //- Construct from type name and mesh
+        noThermo(const word& modelType, const fvMesh& mesh);
+
+
+    //- Destructor
+    virtual ~noThermo();
+
+
+    // Member Functions
+
+        // Fields
+
+            //- Return the film specific heat capacity [J/kg/K]
+            virtual const tmp<volScalarField> Cp() const;
+
+            //- Return solid absortivity [1/m]
+            virtual const volScalarField& kappa() const;
+
+            //- Return the film mean temperature [K]
+            virtual const volScalarField& T() const;
+
+            //- Return density [Kg/m3]
+            virtual const volScalarField& rho() const;
+
+            //- Return thermal conductivity [W/m/K]
+            virtual const volScalarField& K() const;
+
+
+        // Evolution
+
+            //- Pre-evolve film
+            virtual void preEvolveRegion();
+
+            //- Evolve the film equations
+            virtual void evolveRegion();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C
new file mode 100644
index 0000000000..1b066e40e2
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C
@@ -0,0 +1,284 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "thermoBaffle2D.H"
+
+#include "fvm.H"
+#include "addToRunTimeSelectionTable.H"
+#include "zeroGradientFvPatchFields.H"
+#include "fvMatrices.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(thermoBaffle2D, 0);
+
+addToRunTimeSelectionTable(thermoBaffleModel, thermoBaffle2D, mesh);
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+bool thermoBaffle2D::read()
+{
+    this->solution().lookup("nNonOrthCorr") >> nNonOrthCorr_;
+    return regionModel1D::read();
+}
+
+
+void thermoBaffle2D::solveEnergy()
+{
+    if (debug)
+    {
+        Info<< "thermoBaffle2D::solveEnergy()" << endl;
+    }
+
+    const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
+
+    tmp<volScalarField> tQ
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "tQ",
+                regionMesh().time().timeName(),
+                regionMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            regionMesh(),
+            dimensionedScalar("zero", dimEnergy/dimVolume/dimTime, 0.0)
+        )
+    );
+
+    volScalarField& Q = tQ();
+
+    volScalarField rhoCp("rhoCp", thermo_->rho()*thermo_->Cp()());
+    volScalarField K("K", thermo_->K());
+
+
+    //If region is one-dimension variable thickness can be used.
+    if (oneD_)
+    {
+        // Scale K and rhoCp and fill Q in the internal baffle region.
+        const label patchI = intCoupledPatchIDs_[0];
+        const polyPatch& ppCoupled = rbm[patchI];
+
+        forAll(ppCoupled, localFaceI)
+        {
+            const labelList& cells = boundaryFaceCells_[localFaceI];
+            forAll (cells, i)
+            {
+                const label cellId = cells[i];
+
+                Q[cellId] =
+                    Qs_.boundaryField()[patchI][localFaceI]
+                    /thickness_[localFaceI];
+
+                rhoCp[cellId] *= delta_.value()/thickness_[localFaceI];
+
+                K[cellId] *= delta_.value()/thickness_[localFaceI];
+            }
+        }
+    }
+    else
+    {
+        Q = Q_;
+    }
+
+    fvScalarMatrix TEqn
+    (
+        fvm::ddt(rhoCp, T_)
+      - fvm::laplacian(K, T_)
+     ==
+        Q
+    );
+
+    TEqn.relax();
+    TEqn.solve();
+
+    thermo_->correct();
+
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+thermoBaffle2D::thermoBaffle2D
+(
+    const word& modelType,
+    const fvMesh& mesh
+)
+:
+    thermoBaffleModel(modelType, mesh),
+    nNonOrthCorr_(readLabel(solution().lookup("nNonOrthCorr"))),
+    thermo_(basicSolidThermo::New(regionMesh())),
+    T_(thermo_->T()),
+    Qs_
+    (
+        IOobject
+        (
+            "Qs",
+            regionMesh().time().timeName(),
+            regionMesh(),
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        regionMesh(),
+        dimensionedScalar
+        (
+            "zero",
+            dimEnergy/dimArea/dimTime,
+            pTraits<scalar>::zero
+        )
+    ),
+    Q_
+    (
+        IOobject
+        (
+            "Q",
+            regionMesh().time().timeName(),
+            regionMesh(),
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        regionMesh(),
+        dimensionedScalar
+        (
+            "zero",
+            dimEnergy/dimVolume/dimTime,
+            pTraits<scalar>::zero
+        )
+    )
+{
+    if (oneD_)
+    {
+        label patchI = intCoupledPatchIDs_[0];
+        const label Qsb = Qs_.boundaryField()[patchI].size();
+        if (Qsb!= thickness_.size())
+        {
+            FatalErrorIn
+            (
+                "thermoBaffle2D::thermoBaffle2D"
+                "("
+                "   const word& modelType,"
+                "   const fvMesh& mesh"
+                ")"
+            )   << "the boundary field of Qs is "
+                << Qsb << " and " << nl
+                << "the field 'thickness' is " << thickness_.size() << nl
+                << exit(FatalError);
+        }
+    }
+
+    thermo_->correct();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+thermoBaffle2D::~thermoBaffle2D()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void thermoBaffle2D::preEvolveRegion()
+{
+}
+
+
+void thermoBaffle2D::evolveRegion()
+{
+    for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
+    {
+        solveEnergy();
+    }
+}
+
+const tmp<volScalarField> thermoBaffle2D::Cp() const
+{
+    return thermo_->Cp();
+}
+
+const volScalarField& thermoBaffle2D::kappa() const
+{
+    return thermo_->kappa();
+}
+
+const volScalarField& thermoBaffle2D::rho() const
+{
+    return thermo_->rho();
+}
+
+const volScalarField& thermoBaffle2D::K() const
+{
+    return thermo_->K();
+}
+
+const volScalarField& thermoBaffle2D::T() const
+{
+    return T_;
+}
+
+void thermoBaffle2D::info() const
+{
+    Info<< indent << "min/max(T) = " << min(T_).value() << ", "
+        << max(T_).value() << nl;
+
+    const labelList& coupledPatches = intCoupledPatchIDs();
+    forAll (coupledPatches, i)
+    {
+        const label patchI = coupledPatches[i];
+        const fvPatchScalarField& pT = T_.boundaryField()[patchI];
+        const word patchName = regionMesh().boundary()[patchI].name();
+        Info << indent << "Q : " << patchName << indent <<
+            gSum
+            (
+                mag(regionMesh().Sf().boundaryField()[patchI])
+              * pT.snGrad()
+              * thermo_->K().boundaryField()[patchI]
+            ) << endl;
+    }
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // end namespace thermoBaffleModels
+} // end namespace regionModels
+} // end namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.H b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.H
new file mode 100644
index 0000000000..d03682e09f
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.H
@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::thermoBaffle2D
+
+Description
+    2D thermal baffle
+
+SourceFiles
+    thermoBaffle2D.C
+    thermoBaffle2DI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef thermoBaffle2D_H
+#define thermoBaffle2D_H
+
+#include "thermoBaffleModel.H"
+#include "basicSolidThermo.H"
+#include "volFieldsFwd.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+
+/*---------------------------------------------------------------------------*\
+                        Class thermoBaffle2D Declaration
+\*---------------------------------------------------------------------------*/
+
+class thermoBaffle2D
+:
+    public thermoBaffleModel
+{
+private:
+
+    // Private member functions
+
+        //- Disallow default bitwise copy construct
+        thermoBaffle2D(const thermoBaffle2D&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const thermoBaffle2D&);
+
+
+protected:
+
+    // Protected data
+
+        // Solution parameters
+
+            //- Number of non orthogonal correctors
+            label nNonOrthCorr_;
+
+        // Thermo properties
+
+            //- Solid thermo
+            autoPtr<basicSolidThermo> thermo_;
+
+            //- Temperature / [K]
+            volScalarField& T_;
+
+        // Source term fields
+
+            //- Surface energy source  / [J/m2/s]
+            volScalarField Qs_;
+
+            //- Volumetric energy source  / [J/m3/s]
+            volScalarField Q_;
+
+
+    // Protected member functions
+
+        //- Read control parameters from dictionary
+        virtual bool read();
+
+        // Equations
+
+            //- Solve energy equation
+            virtual void solveEnergy();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("thermoBaffle2D");
+
+
+    // Constructors
+
+        //- Construct from components
+        thermoBaffle2D(const word& modelType, const fvMesh& mesh);
+
+
+    //- Destructor
+    virtual ~thermoBaffle2D();
+
+
+    // Member Functions
+
+        // Thermo properties
+
+            //- Return const reference to the basicSolidThermo
+            inline const basicSolidThermo& thermo() const;
+
+
+            // Fields
+
+                //- Return the film specific heat capacity [J/kg/K]
+                virtual const tmp<volScalarField> Cp() const;
+
+                //- Return solid absortivity [1/m]
+                virtual const volScalarField& kappa() const;
+
+                //- Return the film mean temperature [K]
+                virtual const volScalarField& T() const;
+
+                //- Return density [Kg/m3]
+                virtual const volScalarField& rho() const;
+
+                //- Return thermal conductivity [W/m/K]
+                virtual const volScalarField& K() const;
+
+
+            // Helper functions
+
+                //- Return sensible enthalpy as a function of temperature
+                //  for a patch
+                inline tmp<scalarField> hs
+                (
+                    const scalarField& T,
+                    const label patchI
+                ) const;
+
+                //- Return sensible enthalpy as a function of temperature
+                inline tmp<volScalarField> hs
+                (
+                    const volScalarField& T
+                ) const;
+
+                //- Return temperature as a function of sensible enthalpy
+                inline tmp<volScalarField> T
+                (
+                    const volScalarField& hs
+                ) const;
+
+
+        // Evolution
+
+            //- Pre-evolve film
+            virtual void preEvolveRegion();
+
+            //- Evolve the film equations
+            virtual void evolveRegion();
+
+
+
+       // I-O
+
+            //- Provide some feedback
+            virtual void info() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "thermoBaffle2DI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2DI.H b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2DI.H
new file mode 100644
index 0000000000..2324f0534a
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2DI.H
@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "thermoBaffle2D.H"
+#include "zeroGradientFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+inline const basicSolidThermo& thermoBaffle2D::thermo() const
+{
+    return thermo_;
+}
+
+
+inline tmp<scalarField> thermoBaffle2D::hs
+(
+    const scalarField& T,
+    const label patchI
+) const
+{
+    const scalarField& Cp = thermo_->Cp()().boundaryField()[patchI];
+    return Cp*(T - 298.15);
+}
+
+
+inline tmp<volScalarField> thermoBaffle2D::hs
+(
+    const volScalarField& T
+) const
+{
+    const volScalarField Cp = thermo_->Cp()();
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "hs(" + T.name() + ")",
+                time().timeName(),
+                regionMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            Cp*(T - (dimensionedScalar("Tstd", dimTemperature, 298.15))),
+            zeroGradientFvPatchScalarField::typeName
+        )
+    );
+}
+
+
+inline tmp<volScalarField> thermoBaffle2D::T
+(
+    const volScalarField& hs
+) const
+{
+    const volScalarField Cp = thermo_->Cp()();
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                "T(" + hs.name() + ")",
+                time().timeName(),
+                regionMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            hs/Cp + dimensionedScalar("Tstd", dimTemperature, 298.15),
+            zeroGradientFvPatchScalarField::typeName
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C
new file mode 100644
index 0000000000..87883a2df2
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.C
@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "thermoBaffleModel.H"
+#include "fvMesh.H"
+#include "directMappedVariableThicknessWallPolyPatch.H"
+#include "wedgePolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(thermoBaffleModel, 0);
+defineRunTimeSelectionTable(thermoBaffleModel, mesh);
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+bool thermoBaffleModel::read()
+{
+    regionModel1D::read();
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+thermoBaffleModel::thermoBaffleModel(const fvMesh& mesh)
+:
+    regionModel1D(mesh),
+    thickness_(),
+    delta_("delta", dimLength, 0.0),
+    oneD_(false)
+{}
+
+
+thermoBaffleModel::thermoBaffleModel(const word& modelType, const fvMesh& mesh)
+:
+    regionModel1D(mesh, "thermoBaffle", modelType),
+    thickness_(),
+    delta_("delta", dimLength, 0.0),
+    oneD_(false)
+{
+    if (active_)
+    {
+        const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
+
+        // Check if region mesh in oneD
+        label nTotalEdges = 0;
+        const label patchi = intCoupledPatchIDs_[0];
+        nTotalEdges = 2*nLayers_*rbm[patchi].nInternalEdges();
+        nTotalEdges +=
+            nLayers_*(rbm[patchi].nEdges() - rbm[patchi].nInternalEdges());
+
+        reduce(nTotalEdges, sumOp<label>());
+
+        label nFaces = 0;
+        forAll (rbm, patchi)
+        {
+            if (rbm[patchi].size() && isA<wedgePolyPatch>(rbm[patchi]))
+            {
+                nFaces += rbm[patchi].size();
+            }
+        }
+        reduce(nFaces, sumOp<label>());
+
+        if (nTotalEdges == nFaces)
+        {
+            oneD_ = true;
+            Info << "\nThe thermal baffle is 1D \n" << endl;
+        }
+        else
+        {
+            Info << "\nThe thermal baffle is 3D \n" << endl;
+        }
+
+        forAll(intCoupledPatchIDs_, i)
+        {
+            const label patchI = intCoupledPatchIDs_[i];
+            const polyPatch& pp = rbm[patchI];
+
+            if (!isA<directMappedVariableThicknessWallPolyPatch>(pp) && oneD_)
+            {
+                FatalErrorIn
+                (
+                    "thermoBaffleModel::thermoBaffleModel"
+                    "(\n"
+                    "   const word& modelType,"
+                    "   const fvMesh& mesh"
+                    ")\n"
+                )   << "\n    patch type '" << pp.type()
+                    << "' not type '"
+                    << directMappedVariableThicknessWallPolyPatch::typeName
+                    << "'. This is necessary for 1D solution"
+                    << "\n    for patch. " << pp.name()
+                    << exit(FatalError);
+            }
+            else if (!isA<directMappedWallPolyPatch>(pp))
+            {
+                FatalErrorIn
+                (
+                    "thermoBaffleModel::thermoBaffleModel"
+                    "(\n"
+                    "   const word& modelType,"
+                    "   const fvMesh& mesh"
+                    ")\n"
+                )   << "\n    patch type '" << pp.type()
+                    << "' not type '"
+                    << directMappedWallPolyPatch::typeName
+                    << "'. This is necessary for 3D solution"
+                    << "\n    for patch. " << pp.name()
+                    << exit(FatalError);
+            }
+        }
+
+        if (oneD_)
+        {
+            const label patchI = intCoupledPatchIDs_[0];
+            const polyPatch& pp = rbm[patchI];
+            const directMappedVariableThicknessWallPolyPatch& ppCoupled =
+                refCast
+                <
+                    const directMappedVariableThicknessWallPolyPatch
+                >(pp);
+
+            thickness_ = ppCoupled.thickness();
+
+            // Check that thickness has the right size
+            if (thickness_.size() != pp.size())
+            {
+                FatalErrorIn
+                (
+                    "thermoBaffleModel::thermoBaffleModel"
+                    "("
+                    "   const word& modelType,"
+                    "   const fvMesh& mesh"
+                    ")"
+                )   << " coupled patches in thermoBaffle are " << nl
+                    << " different sizes from list thickness" << nl
+                    << exit(FatalError);
+            }
+
+            // Calculate thickness of the baffle on the first face only.
+            if (delta_.value() == 0.0)
+            {
+                forAll (ppCoupled, localFaceI)
+                {
+                    label faceI = ppCoupled.start() + localFaceI;
+
+                    label faceO =
+                        boundaryFaceOppositeFace_[localFaceI];
+
+                    delta_.value() = mag
+                    (
+                        regionMesh().faceCentres()[faceI]
+                      - regionMesh().faceCentres()[faceO]
+                    );
+                    break;
+                }
+            }
+        }
+
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+thermoBaffleModel::~thermoBaffleModel()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void thermoBaffleModel::preEvolveRegion()
+{
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.H b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.H
new file mode 100644
index 0000000000..3d8dabc876
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModel.H
@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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::thermoBaffleModel
+
+Description
+
+SourceFiles
+    thermoBaffleModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef thermoBaffleModel_H
+#define thermoBaffleModel_H
+
+#include "runTimeSelectionTables.H"
+#include "scalarIOField.H"
+#include "autoPtr.H"
+#include "volFieldsFwd.H"
+#include "regionModel1D.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class thermoBaffleModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class thermoBaffleModel
+:
+    public regionModel1D
+{
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        thermoBaffleModel(const thermoBaffleModel&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const thermoBaffleModel&);
+
+
+protected:
+
+    // Protected Data
+
+        //- Baffle physical thickness
+        scalarField thickness_;
+
+        //- Baffle geometric thickness
+        dimensionedScalar delta_;
+
+        //- Is it one dimension
+        bool oneD_;
+
+
+    // Protected Member Functions
+
+        //- Read control parameters from dictionary
+        virtual bool read();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("thermoBaffleModel");
+
+
+    // Declare runtime constructor selection table
+
+         declareRunTimeSelectionTable
+         (
+             autoPtr,
+             thermoBaffleModel,
+             mesh,
+             (
+                const word& modelType,
+                const fvMesh& mesh
+             ),
+             (modelType, mesh)
+         );
+
+    // Constructors
+
+        //- Construct null from mesh
+        thermoBaffleModel(const fvMesh& mesh);
+
+        //- Construct from type name and mesh
+        thermoBaffleModel(const word& modelType, const fvMesh& mesh);
+
+
+    // Selectors
+
+        //- Return a reference to the selected model
+         static autoPtr<thermoBaffleModel> New(const fvMesh& mesh);
+
+
+    //- Destructor
+    virtual ~thermoBaffleModel();
+
+
+    // Member Functions
+
+        // Access
+
+
+            //- Return thickness
+            const scalarField& thickness() const
+            {
+                return thickness_;
+            }
+
+            //- Return geometrical thickness
+            const dimensionedScalar& delta() const
+            {
+                return delta_;
+            }
+
+             //- Return if region is one dimensional
+            bool oneD() const
+            {
+                return oneD_;
+            }
+
+
+            // Fields
+
+                //- Return density [kg/m3]
+                virtual const volScalarField& rho() const = 0;
+
+                //- Return const temperature [K]
+                virtual const volScalarField& T() const = 0;
+
+                //- Return specific heat capacity [J/kg/K]
+                virtual const tmp<volScalarField> Cp() const = 0;
+
+                //- Return the region absorptivity [1/m]
+                virtual const volScalarField& kappa() const = 0;
+
+                //- Return the region thermal conductivity [W/m/k]
+                virtual const volScalarField& K() const = 0;
+
+
+        // Evolution
+
+            //- Pre-evolve region
+            virtual void preEvolveRegion();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModelNew.C b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModelNew.C
new file mode 100644
index 0000000000..976b478e33
--- /dev/null
+++ b/src/regionModels/thermoBaffleModels/thermoBaffleModel/thermoBaffleModelNew.C
@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 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 "thermoBaffleModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace regionModels
+{
+namespace thermoBaffleModels
+{
+
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
+
+autoPtr<thermoBaffleModel> thermoBaffleModel::New(const fvMesh& mesh)
+{
+
+    word modelType;
+    {
+        IOdictionary thermoBafflePropertiesDict
+        (
+            IOobject
+            (
+                "thermoBaffleProperties",
+                mesh.time().constant(),
+                mesh,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE,
+                false
+            )
+        );
+
+        thermoBafflePropertiesDict.lookup("thermoBaffleModel") >> modelType;
+    }
+    Info<< "Selecting baffle model " << modelType << endl;
+
+    meshConstructorTable::iterator cstrIter =
+        meshConstructorTablePtr_->find(modelType);
+
+    if (cstrIter == meshConstructorTablePtr_->end())
+    {
+
+        FatalErrorIn("thermoBaffleModel::New(const fvMesh&)")
+            << "Unknown thermoBaffleModel type " << modelType
+            << nl << nl
+            <<  "Valid thermoBaffleModel types are:" << nl
+            << meshConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<thermoBaffleModel>(cstrIter()(modelType, mesh));
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace thermoBaffleModels
+} // End namespace regionModels
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/filter/constant/reactingCloud1Properties b/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/filter/constant/reactingCloud1Properties
index 4eaea3d71a..e2149b798d 100644
--- a/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/filter/constant/reactingCloud1Properties
+++ b/tutorials/lagrangian/porousExplicitSourceReactingParcelFoam/filter/constant/reactingCloud1Properties
@@ -175,6 +175,18 @@ cloudFunctions
             cycLeft_half1
         );
     }
+
+    facePostProcessing
+    {
+        surfaceFormat   vtk;
+        resetOnWrite    no;
+        log             yes;
+
+        faceZones
+        (
+            cycLeft
+        );
+    }
 }
 
 
diff --git a/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties b/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
index 4a033313dc..c31c76b974 100644
--- a/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
+++ b/tutorials/lagrangian/sprayFoam/aachenBomb/constant/sprayCloudProperties
@@ -112,8 +112,9 @@ subModels
         massTotal       6.0e-6;
         parcelBasisType mass;
         injectionMethod disc;
-        outerNozzleDiameter 1.9e-4;
-        innerNozzleDiameter 0;
+        flowType        flowRateAndDischarge;
+        outerDiameter   1.9e-4;
+        innerDiameter   0;
         duration        1.25e-3;
         position        ( 0 0.0995 0 );
         direction       ( 0 -1 0 );