From f53f614c430264d69c29295921bf40dabfbf370d Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Thu, 24 Apr 2008 13:16:10 +0100
Subject: [PATCH] Initial autoMesh merge

---
 .../mesh/conversion/plot3dToFoam/hexBlock.C   |   52 +-
 .../mesh/conversion/plot3dToFoam/hexBlock.H   |    9 +-
 .../conversion/plot3dToFoam/plot3dToFoam.C    |   46 +-
 .../manipulation/Optional/setSet/setSet.C     |   57 +-
 .../couplePatches/FoamX/couplePatches.cfg     |   27 -
 .../manipulation/couplePatches/Make/files     |    3 -
 .../manipulation/couplePatches/Make/options   |    7 -
 .../couplePatches/couplePatches.C             |  160 -
 src/Allwmake                                  |    2 +
 .../containers/Lists/ListOps/ListOps.H        |   48 +-
 .../Lists/ListOps/ListOpsTemplates.C          |   96 +-
 src/autoMesh/Make/files                       |   18 +
 src/autoMesh/Make/options                     |   21 +
 .../autoHexMeshDriver/autoHexMeshDriver.C     | 1604 +++++++++
 .../autoHexMeshDriver/autoHexMeshDriver.H     |  810 +++++
 .../autoHexMeshDriverLayers.C                 | 2999 +++++++++++++++++
 .../autoHexMeshDriverShrink.C                 | 1151 +++++++
 .../autoHexMeshDriver/autoHexMeshDriverSnap.C | 1196 +++++++
 .../autoHexMeshDriverTemplates.C              |   75 +
 .../autoHexMeshDriver/pointData/pointData.C   |   53 +
 .../autoHexMeshDriver/pointData/pointData.H   |  228 ++
 .../autoHexMeshDriver/pointData/pointDataI.H  |  356 ++
 .../meshRefinement/meshRefinement.C           | 2011 +++++++++++
 .../meshRefinement/meshRefinement.H           |  667 ++++
 .../meshRefinement/meshRefinementBaffles.C    | 2719 +++++++++++++++
 .../meshRefinement/meshRefinementMerge.C      |  230 ++
 .../meshRefinement/meshRefinementRefine.C     | 1360 ++++++++
 .../meshRefinement/meshRefinementTemplates.C  |  195 ++
 .../offsetTriSurfaceMesh.C                    |  199 ++
 .../offsetTriSurfaceMesh.H                    |  167 +
 .../refinementSurfaces/refinementSurfaces.C   |  503 +++
 .../refinementSurfaces/refinementSurfaces.H   |  279 ++
 .../trackedParticle/ExactParticle.C           |  263 ++
 .../trackedParticle/ExactParticle.H           |  193 ++
 .../autoHexMesh/trackedParticle/Particle.H    |  431 +++
 .../trackedParticle/trackedParticle.C         |  261 ++
 .../trackedParticle/trackedParticle.H         |  276 ++
 .../trackedParticle/trackedParticleCloud.C    |   44 +
 38 files changed, 18566 insertions(+), 250 deletions(-)
 delete mode 100644 applications/utilities/mesh/manipulation/couplePatches/FoamX/couplePatches.cfg
 delete mode 100644 applications/utilities/mesh/manipulation/couplePatches/Make/files
 delete mode 100644 applications/utilities/mesh/manipulation/couplePatches/Make/options
 delete mode 100644 applications/utilities/mesh/manipulation/couplePatches/couplePatches.C
 create mode 100644 src/autoMesh/Make/files
 create mode 100644 src/autoMesh/Make/options
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointDataI.H
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
 create mode 100644 src/autoMesh/autoHexMesh/meshRefinement/meshRefinementTemplates.C
 create mode 100644 src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.C
 create mode 100644 src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.H
 create mode 100644 src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
 create mode 100644 src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.H
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/Particle.H
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.C
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.H
 create mode 100644 src/autoMesh/autoHexMesh/trackedParticle/trackedParticleCloud.C

diff --git a/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.C b/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.C
index 7a5ebd43c7..5a1b39cd78 100644
--- a/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.C
+++ b/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.C
@@ -87,7 +87,7 @@ void hexBlock::setHandedness()
 
     if (blockHandedness_ == noPoints)
     {
-        WarningIn("hexBlock::readPoints(const bool, Istream&)")
+        WarningIn("hexBlock::hexBlock::setHandedness()")
             << "Cannot determine orientation of block."
             << " Continuing as if right handed." << endl;
         blockHandedness_ = right;
@@ -105,35 +105,67 @@ hexBlock::hexBlock(const label nx, const label ny, const label nz)
     zDim_(nz - 1),
     blockHandedness_(noPoints),
     points_((xDim_ + 1)*(yDim_ + 1)*(zDim_ + 1))
-{
-    Pout<< "xDim:" << nx << " yDim:" << ny << " zDim:" << nz << endl;
-}
+{}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void hexBlock::readPoints(const bool readBlank, Istream& is)
+void hexBlock::readPoints
+(
+    const bool readBlank,
+    const scalar twoDThicknes,
+    Istream& is
+)
 {
     scalar iBlank;
 
-    forAll (points_, i)
+    label nPoints = points_.size();
+
+    if (twoDThicknes > 0)
+    {
+        nPoints /= 2;
+    }
+
+    Info<< "Reading " << nPoints << " x coordinates..." << endl;
+    for (label i=0; i < nPoints; i++)
     {
         is >> points_[i].x();
     }
 
-    forAll (points_, i)
+    Info<< "Reading " << nPoints << " y coordinates..." << endl;
+    for (label i=0; i < nPoints; i++)
     {
         is >> points_[i].y();
     }
 
-    forAll (points_, i)
+    if (twoDThicknes > 0)
     {
-        is >> points_[i].z();
+        Info<< "Extruding " << nPoints << " points in z direction..." << endl;
+        // Duplicate points
+        for (label i=0; i < nPoints; i++)
+        {
+            points_[i+nPoints] = points_[i];
+        }
+        for (label i=0; i < nPoints; i++)
+        {
+            points_[i].z() = 0;
+            points_[i+nPoints].z() = twoDThicknes;
+        }
     }
+    else
+    {
+        Info<< "Reading " << nPoints << " z coordinates..." << endl;
+        for (label i=0; i < nPoints; i++)
+        {
+            is >> points_[i].z();
+        }
+    }
+
 
     if (readBlank)
     {
-        forAll (points_, i)
+        Info<< "Reading " << nPoints << " blanks..." << endl;
+        for (label i=0; i < nPoints; i++)
         {
             is >> iBlank;
         }
diff --git a/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.H b/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.H
index 2adfe841ef..38763c8e93 100644
--- a/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.H
+++ b/applications/utilities/mesh/conversion/plot3dToFoam/hexBlock.H
@@ -145,7 +145,14 @@ public:
 
 
         //- Read block points either with or without blanking after every block.
-        void readPoints(const bool readBlank, Istream&);
+        //  If twoDThickness > 0 reads (half) the points and extrudes the
+        //  points in z direction.
+        void readPoints
+        (
+            const bool readBlank,
+            const scalar twoDThicknes,
+            Istream&
+        );
 };
 
 
diff --git a/applications/utilities/mesh/conversion/plot3dToFoam/plot3dToFoam.C b/applications/utilities/mesh/conversion/plot3dToFoam/plot3dToFoam.C
index 0c7254b2a0..4c503a932a 100644
--- a/applications/utilities/mesh/conversion/plot3dToFoam/plot3dToFoam.C
+++ b/applications/utilities/mesh/conversion/plot3dToFoam/plot3dToFoam.C
@@ -23,11 +23,12 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Description
-    Plot3d mesh (ascii format) converter.
+    Plot3d mesh (ascii/formatted format) converter.
 
     Work in progress! Handles ascii multiblock (and optionally singleBlock)
     format.
     By default expects blanking. Use -noBlank if none.
+    Use -2D <thickness> if 2D.
     Niklas Nordin has experienced a problem with lefthandedness of the blocks.
     The code should detect this automatically - see hexBlock::readPoints but
     if this goes wrong just set the blockHandedness_ variable to 'right'
@@ -59,6 +60,7 @@ int main(int argc, char *argv[])
     argList::validOptions.insert("scale", "scale factor");
     argList::validOptions.insert("noBlank", "");
     argList::validOptions.insert("singleBlock", "");
+    argList::validOptions.insert("2D", "thickness");
 
     argList args(argc, argv);
 
@@ -75,6 +77,13 @@ int main(int argc, char *argv[])
 
     bool readBlank = !args.options().found("noBlank");
     bool singleBlock = args.options().found("singleBlock");
+    scalar twoDThicknes = -1;
+    if (args.options().found("2D"))
+    {
+        twoDThicknes = readScalar(IStringStream(args.options()["2D"])());
+        Info<< "Reading 2D case by extruding points by " << twoDThicknes
+            << " in z direction." << nl << endl;
+    }
 
 
 #   include "createTime.H"
@@ -95,7 +104,7 @@ int main(int argc, char *argv[])
         plot3dFile >> nblock;
     }
 
-    Info << "Reading " << nblock << " blocks" << endl;
+    Info<< "Reading " << nblock << " blocks" << endl;
 
     PtrList<hexBlock> blocks(nblock);
 
@@ -104,20 +113,32 @@ int main(int argc, char *argv[])
 
         forAll (blocks, blockI)
         {
-            plot3dFile >> nx >> ny >> nz;
+            if (twoDThicknes > 0)
+            {
+                // Fake second set of points (done in readPoints below)
+                plot3dFile >> nx >> ny;
+                nz = 2;
+            }
+            else
+            {
+                plot3dFile >> nx >> ny >> nz;
+            }
+
+            Info<< "block " << blockI << " nx:" << nx
+                << " ny:" << ny << " nz:" << nz << endl;
 
             blocks.set(blockI, new hexBlock(nx, ny, nz));
         }
     }
 
-    Info << "Reading block points" << endl;
+    Info<< "Reading block points" << endl;
     label sumPoints(0);
     label nMeshCells(0);
 
     forAll (blocks, blockI)
     {
-        Info << "block " << blockI << ":" << nl;
-        blocks[blockI].readPoints(readBlank, plot3dFile);
+        Info<< "block " << blockI << ":" << nl;
+        blocks[blockI].readPoints(readBlank, twoDThicknes, plot3dFile);
         sumPoints += blocks[blockI].nBlockPoints();
         nMeshCells += blocks[blockI].nBlockCells();
         Info<< nl;
@@ -136,7 +157,6 @@ int main(int argc, char *argv[])
         }
     }
 
-
     // From old to new master point
     labelList oldToNew;
     pointField newPoints;
@@ -151,13 +171,17 @@ int main(int argc, char *argv[])
         newPoints
     );
 
+    Info<< "Merged points within " << SMALL << " distance. Merged from "
+        << oldToNew.size() << " down to " << newPoints.size()
+        << " points." << endl;
+
     // Scale the points
     if (scaleFactor > 1.0 + SMALL || scaleFactor < 1.0 - SMALL)
     {
         newPoints *= scaleFactor;
     }
 
-    Info << "Creating cells" << endl;
+    Info<< "Creating cells" << endl;
 
     cellShapeList cellShapes(nMeshCells);
 
@@ -190,7 +214,7 @@ int main(int argc, char *argv[])
         }
     }
 
-    Info << "Creating boundary patches" << endl;
+    Info<< "Creating boundary patches" << endl;
 
     faceListList boundary(0);
     wordList patchNames(0);
@@ -220,10 +244,10 @@ int main(int argc, char *argv[])
     // Set the precision of the points data to 10
     IOstream::defaultPrecision(10);
 
-    Info << "Writing polyMesh" << endl;
+    Info<< "Writing polyMesh" << endl;
     pShapeMesh.write();
 
-    Info << "End\n" << endl;
+    Info<< "End\n" << endl;
 
     return 0;
 }
diff --git a/applications/utilities/mesh/manipulation/Optional/setSet/setSet.C b/applications/utilities/mesh/manipulation/Optional/setSet/setSet.C
index 2df4dd88ae..64dd8c1ca7 100644
--- a/applications/utilities/mesh/manipulation/Optional/setSet/setSet.C
+++ b/applications/utilities/mesh/manipulation/Optional/setSet/setSet.C
@@ -42,6 +42,7 @@ Description
 #include "demandDrivenData.H"
 #include "writePatch.H"
 #include "writePointSet.H"
+#include "IOobjectList.H"
 
 #include <stdio.h>
 
@@ -233,8 +234,10 @@ void writeVTK
 
 void printHelp(Ostream& os)
 {
-    os  << "Please type 'help', 'quit', 'time ddd'"
+    os  << "Please type 'help', 'list', 'quit', 'time ddd'"
         << " or a set command after prompt." << endl
+        << "'list' will show all current cell/face/point sets." << endl
+        << "'time ddd' will change the current time." << endl
         << endl
         << "A set command should be of the following form" << endl
         << endl
@@ -272,6 +275,47 @@ void printHelp(Ostream& os)
 }
 
 
+void printAllSets(const polyMesh& mesh, Ostream& os)
+{
+    IOobjectList objects
+    (
+        mesh,
+        mesh.pointsInstance(),
+        polyMesh::meshSubDir/"sets"
+    );
+    IOobjectList cellSets(objects.lookupClass(cellSet::typeName));
+    if (cellSets.size() > 0)
+    {
+        os  << "cellSets:" << endl;
+        forAllConstIter(IOobjectList, cellSets, iter)
+        {
+            cellSet set(*iter());
+            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
+        }
+    }
+    IOobjectList faceSets(objects.lookupClass(faceSet::typeName));
+    if (faceSets.size() > 0)
+    {
+        os  << "faceSets:" << endl;
+        forAllConstIter(IOobjectList, faceSets, iter)
+        {
+            faceSet set(*iter());
+            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
+        }
+    }
+    IOobjectList pointSets(objects.lookupClass(pointSet::typeName));
+    if (pointSets.size() > 0)
+    {
+        os  << "pointSets:" << endl;
+        forAllConstIter(IOobjectList, pointSets, iter)
+        {
+            pointSet set(*iter());
+            os  << '\t' << set.name() << "\tsize:" << set.size() << endl;
+        }
+    }
+    os  << endl;
+}
+
 
 // Read command and execute. Return true if ok, false otherwise.
 bool doCommand
@@ -531,6 +575,12 @@ commandStatus parseType
 
         return INVALID;
     }
+    else if (setType == "list")
+    {
+        printAllSets(mesh, Pout);
+
+        return INVALID;
+    }
     else if (setType == "time")
     {
         scalar time = readScalar(is);
@@ -612,8 +662,9 @@ commandStatus parseType
         (
             "commandStatus parseType(Time&, polyMesh&, const word&"
             ", IStringStream&)"
-        )   << "Illegal set type " << setType << endl
-            << "Should be one of 'cellSet' 'faceSet' 'pointSet'"
+        )   << "Illegal command " << setType << endl
+            << "Should be one of 'help', 'list', 'time' or a set type :"
+            << " 'cellSet', 'faceSet', 'pointSet'"
             << endl;
 
         return INVALID;
diff --git a/applications/utilities/mesh/manipulation/couplePatches/FoamX/couplePatches.cfg b/applications/utilities/mesh/manipulation/couplePatches/FoamX/couplePatches.cfg
deleted file mode 100644
index 4265e8f37d..0000000000
--- a/applications/utilities/mesh/manipulation/couplePatches/FoamX/couplePatches.cfg
+++ /dev/null
@@ -1,27 +0,0 @@
-/*---------------------------------------------------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  1.0                                   |
-|   \\  /    A nd           | Web:      http://www.openfoam.org               |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-// couplePatches tool definition
-
-description     "Utility to reorder face numbering for cyclic and processor patches";
-
-couplePatchesDict
-{
-    type            dictionary;
-    description     "couplePatches control dictionary";
-    dictionaryPath  "system";
-
-    entries
-    {
-        arguments
-        {
-            type        rootCaseArguments;
-        }
-    }
-}
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/manipulation/couplePatches/Make/files b/applications/utilities/mesh/manipulation/couplePatches/Make/files
deleted file mode 100644
index a5f95c1a12..0000000000
--- a/applications/utilities/mesh/manipulation/couplePatches/Make/files
+++ /dev/null
@@ -1,3 +0,0 @@
-couplePatches.C
-
-EXE = $(FOAM_APPBIN)/couplePatches
diff --git a/applications/utilities/mesh/manipulation/couplePatches/Make/options b/applications/utilities/mesh/manipulation/couplePatches/Make/options
deleted file mode 100644
index 73f34b0f85..0000000000
--- a/applications/utilities/mesh/manipulation/couplePatches/Make/options
+++ /dev/null
@@ -1,7 +0,0 @@
-EXE_INC = \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
-
-EXE_LIBS = \
-    -ldynamicMesh \
-    -lmeshTools
diff --git a/applications/utilities/mesh/manipulation/couplePatches/couplePatches.C b/applications/utilities/mesh/manipulation/couplePatches/couplePatches.C
deleted file mode 100644
index 004e44adb3..0000000000
--- a/applications/utilities/mesh/manipulation/couplePatches/couplePatches.C
+++ /dev/null
@@ -1,160 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Description
-    Utility to reorder cyclic and processor patches.
-
-    Uses dummy morph to sort things out.
-
-    Is bit of hack since polyMesh constructor already checks for coupled
-    face areas so might bomb out. You might need to compile in a local
-    processorPolyPatch that gives a warning instead to make this utility
-    complete.
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "polyMesh.H"
-#include "Time.H"
-#include "polyTopoChange.H"
-#include "mapPolyMesh.H"
-#include "OFstream.H"
-#include "coupledPolyPatch.H"
-#include "PstreamReduceOps.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// Main program:
-
-int main(int argc, char *argv[])
-{
-#   include "setRootCase.H"
-#   include "createTime.H"
-#   include "createPolyMesh.H"
-
-    Info<< "Using geometry to calculate face correspondence across"
-        << " coupled boundaries (processor, cyclic)" << nl
-        << "This will only work for cyclics if they are parallel or"
-        << " their rotation is defined across the origin" << nl
-        << endl;
-
-    const polyBoundaryMesh& patches = mesh.boundaryMesh();
-
-    bool hasCoupled = false;
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if (pp.coupled())
-        {
-            hasCoupled = true;
-
-            break;
-        }
-    }
-
-    reduce(hasCoupled, orOp<bool>());
-
-    if (hasCoupled)
-    {
-        Info<< "Mesh has coupled patches ..." << nl << endl;
-
-        // Dummy topo changes container
-        polyTopoChange meshMod(mesh);
-
-        // Do all changes
-        Info<< "Doing dummy mesh morph to correct face ordering ..."
-            << endl;
-
-        runTime++;
-
-        faceList oldFaces(mesh.faces());
-
-        autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh, false);
-
-        // Update fields
-        mesh.updateMesh(morphMap);
-
-        // Move mesh (since morphing does not do this)
-        if (morphMap().hasMotionPoints())
-        {
-            mesh.movePoints(morphMap().preMotionPoints());
-        }
-
-        // Find out if anything changed.
-        // Problem is that - if the topo change is only rotation -
-        // face::operator= does not detect a change so use labelList::operator=
-        bool meshChanged = false;
-
-        if (mesh.faces().size() != oldFaces.size())
-        {
-            meshChanged = true;
-        }
-        else
-        {
-            forAll(mesh.faces(), faceI)
-            {
-                const labelList& f = mesh.faces()[faceI];
-                const labelList& oldF = oldFaces[faceI];
-
-                if (f != oldF)
-                {
-                    meshChanged = true;
-                    break;
-                }
-            }
-        }
-
-        reduce(meshChanged, orOp<label>());
-
-        if (meshChanged)
-        {
-            // Set the precision of the points data to 10
-            IOstream::defaultPrecision(10);
-
-            // Write resulting mesh
-            Info << "Writing morphed mesh to time " << runTime.value() << endl;
-
-            mesh.write();
-        }
-        else
-        {
-            Info << "Mesh ordering ok. Nothing changed." << endl;
-        }
-    }
-    else
-    {
-        Info<< "Mesh has no coupled patches. Nothing changed ..." << nl << endl;
-    }
-        
-
-    Info << "End\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //
diff --git a/src/Allwmake b/src/Allwmake
index 29dfe503c3..ba639cabc0 100755
--- a/src/Allwmake
+++ b/src/Allwmake
@@ -41,6 +41,8 @@ wmake libso randomProcesses
 
 ( cd postProcessing && ./Allwmake )
 
+wmake libso autoMesh
+
 wmake libso errorEstimation
 
 
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
index 6ea9250f3f..15e264ab74 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
@@ -1,3 +1,4 @@
+
 /*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
@@ -26,7 +27,7 @@ InNamspace
     Foam
 
 Description
-    ListOps. Various functions to operate on Lists.
+    Various functions to operate on Lists.
 
 SourceFiles
     ListOps.C
@@ -66,6 +67,17 @@ template<class List>
 void inplaceReorder(const labelList& oldToNew, List&);
 
 
+// Variants to work with iterators and sparse tables. Need to have iterators
+// and insert()
+
+//- Map values. Do not map negative values.
+template<class Container>
+void inplaceMapValue(const labelList& oldToNew, Container&);
+//- Recreate with mapped keys. Remove elements with negative key.
+template<class Container>
+void inplaceMapKey(const labelList& oldToNew, Container&);
+
+
 //- Extract elements of List whose region is certain value. Use e.g.
 //  to extract all selected elements:
 //  subset<boolList, labelList>(selectedElems, true, lst);
@@ -103,11 +115,21 @@ labelList identity(const label len);
 //- Find first occurence of given element and return index,
 //  return -1 if not found. Linear search.
 template<class List>
-label findIndex(const List&, typename List::const_reference);
+label findIndex
+(
+    const List&,
+    typename List::const_reference,
+    const label start=0
+);
 
 //- Find all occurences of given element. Linear search.
 template<class List>
-labelList findIndices(const List&, typename List::const_reference);
+labelList findIndices
+(
+    const List&,
+    typename List::const_reference,
+    const label start=0
+);
 
 //- Opposite of findIndices: set values at indices to given value
 template<class List>
@@ -123,7 +145,7 @@ template<class List>
 List createWithValues
 (
     const label sz,
-    typename List::const_reference initValue,
+    const typename List::const_reference initValue,
     const labelList& indices,
     typename List::const_reference setValue
 );
@@ -131,25 +153,35 @@ List createWithValues
 //- Find index of max element (and larger than given element).
 //  return -1 if not found. Linear search.
 template<class List>
-label findMax(const List&);
+label findMax(const List&, const label start=0);
 
 
 //- Find index of min element (and less than given element).
 //  return -1 if not found. Linear search.
 template<class List>
-label findMin(const List&);
+label findMin(const List&, const label start=0);
 
 
 //- Find first occurence of given element in sorted list and return index,
 //  return -1 if not found. Binary search.
 template<class List>
-label findSortedIndex(const List&, typename List::const_reference);
+label findSortedIndex
+(
+    const List&,
+    typename List::const_reference,
+    const label start=0
+);
 
 
 //- Find last element < given value in sorted list and return index,
 //  return -1 if not found. Binary search.
 template<class List>
-label findLower(const List&, typename List::const_reference);
+label findLower
+(
+    const List&,
+    typename List::const_reference,
+    const label start=0
+);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
index c42b75e461..a68a66b44c 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
@@ -118,6 +118,54 @@ void Foam::inplaceReorder
 }
 
 
+template<class Container>
+void Foam::inplaceMapValue
+(
+    const labelList& oldToNew,
+    Container& lst
+)
+{
+    for
+    (
+        typename Container::iterator iter = lst.begin();
+        iter != lst.end();
+        ++iter
+    )
+    {
+        if (iter() >= 0)
+        {
+            iter() = oldToNew[iter()];
+        }
+    }
+}
+
+
+template<class Container>
+void Foam::inplaceMapKey
+(
+    const labelList& oldToNew,
+    Container& lst
+)
+{
+    Container newLst(lst);
+
+    for
+    (
+        typename Container::iterator iter = lst.begin();
+        iter != lst.end();
+        ++iter
+    )
+    {
+        if (iter.key() >= 0)
+        {
+            newLst.insert(oldToNew[iter.key()], iter());
+        }
+    }
+    
+    lst.transfer(newLst);
+}
+
+
 template<class T, class List>
 List Foam::subset(const UList<T>& regions, const T& region, const List& lst)
 {
@@ -221,11 +269,16 @@ void Foam::invertManyToMany
 
 
 template<class List>
-Foam::label Foam::findIndex(const List& l, typename List::const_reference t)
+Foam::label Foam::findIndex
+(
+    const List& l,
+    typename List::const_reference t,
+    const label start
+)
 {
     label index = -1;
 
-    forAll(l, i)
+    for (label i = start; i < l.size(); i++)
     {
         if (l[i] == t)
         {
@@ -242,13 +295,14 @@ template<class List>
 Foam::labelList Foam::findIndices
 (
     const List& l,
-    typename List::const_reference t
+    typename List::const_reference t,
+    const label start
 )
 {
     // Count occurrences
     label n = 0;
 
-    forAll(l, i)
+    for (label i = start; i < l.size(); i++)
     {
         if (l[i] == t)
         {
@@ -260,7 +314,7 @@ Foam::labelList Foam::findIndices
     labelList indices(n);
     n = 0;
 
-    forAll(l, i)
+    for (label i = start; i < l.size(); i++)
     {
         if (l[i] == t)
         {
@@ -291,7 +345,7 @@ template<class List>
 List Foam::createWithValues
 (
     const label sz,
-    typename List::const_reference initValue,
+    const typename List::const_reference initValue,
     const labelList& indices,
     typename List::const_reference setValue
 )
@@ -303,16 +357,16 @@ List Foam::createWithValues
 
 
 template<class List>
-Foam::label Foam::findMax(const List& l)
+Foam::label Foam::findMax(const List& l, const label start)
 {
-    if (l.size() == 0)
+    if (start >= l.size())
     {
         return -1;
     }
 
-    label index = 0;
+    label index = start;
 
-    for (label i = 1; i < l.size(); i++)
+    for (label i = start+1; i < l.size(); i++)
     {
         if (l[i] > l[index])
         {
@@ -325,16 +379,16 @@ Foam::label Foam::findMax(const List& l)
 
 
 template<class List>
-Foam::label Foam::findMin(const List& l)
+Foam::label Foam::findMin(const List& l, const label start)
 {
-    if (l.size() == 0)
+    if (start >= l.size())
     {
         return -1;
     }
 
-    label index = 0;
+    label index = start;
 
-    for (label i = 1; i < l.size(); i++)
+    for (label i = start+1; i < l.size(); i++)
     {
         if (l[i] < l[index])
         {
@@ -350,15 +404,16 @@ template<class List>
 Foam::label Foam::findSortedIndex
 (
     const List& l,
-    typename List::const_reference t
+    typename List::const_reference t,
+    const label start
 )
 {
-    if (l.size() == 0)
+    if (start >= l.size())
     {
         return -1;
     }
 
-    label low = 0;
+    label low = start;
     label high = l.size() - 1;
 
     while (low <= high)
@@ -387,15 +442,16 @@ template<class List>
 Foam::label Foam::findLower
 (
     const List& l,
-    typename List::const_reference t
+    typename List::const_reference t,
+    const label start
 )
 {
-    if (l.size() == 0)
+    if (start >= l.size())
     {
         return -1;
     }
 
-    label low = 0;
+    label low = start;
     label high = l.size() - 1;
 
     while ((high - low) > 1)
diff --git a/src/autoMesh/Make/files b/src/autoMesh/Make/files
new file mode 100644
index 0000000000..20e68a05fe
--- /dev/null
+++ b/src/autoMesh/Make/files
@@ -0,0 +1,18 @@
+autoHexMesh             = autoHexMesh
+
+$(autoHexMesh)/autoHexMeshDriver/autoHexMeshDriver.C
+$(autoHexMesh)/autoHexMeshDriver/autoHexMeshDriverLayers.C
+$(autoHexMesh)/autoHexMeshDriver/autoHexMeshDriverShrink.C
+$(autoHexMesh)/autoHexMeshDriver/autoHexMeshDriverSnap.C
+$(autoHexMesh)/autoHexMeshDriver/pointData/pointData.C
+$(autoHexMesh)/meshRefinement/meshRefinementBaffles.C
+$(autoHexMesh)/meshRefinement/meshRefinement.C
+$(autoHexMesh)/meshRefinement/meshRefinementMerge.C
+$(autoHexMesh)/meshRefinement/meshRefinementRefine.C
+$(autoHexMesh)/refinementSurfaces/refinementSurfaces.C
+$(autoHexMesh)/offsetTriSurfaceMesh/offsetTriSurfaceMesh.C
+$(autoHexMesh)/trackedParticle/trackedParticle.C
+$(autoHexMesh)/trackedParticle/trackedParticleCloud.C
+
+LIB = $(FOAM_LIBBIN)/libautoMesh
+
diff --git a/src/autoMesh/Make/options b/src/autoMesh/Make/options
new file mode 100644
index 0000000000..6488bd846f
--- /dev/null
+++ b/src/autoMesh/Make/options
@@ -0,0 +1,21 @@
+/* include /home/pinky2/mattijs/pub/Delaunay/CGAL-3.1/make/makefile_i686_Linux-2.6.4-52-default_g++-3.4.3 */
+
+EXE_INC = \
+    /* -g -DFULLDEBUG -O0 $(CGAL_CXXFLAGS) */ \
+    -I$(FOAM_UTILITIES)/parallelProcessing/decompositionMethods/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(FOAM_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/edgeMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+
+LIB_LIBS = \
+    -ldecompositionMethods \
+    -ldynamicMesh \
+    -lfiniteVolume \
+    -llagrangian \
+    -lmeshTools \
+    -ledgeMesh \
+    -ltriSurface \
+ /*   $(CGAL_LDFLAGS) */
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
new file mode 100644
index 0000000000..3a4baaa724
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
@@ -0,0 +1,1604 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    autoHexMeshDriver
+
+\*----------------------------------------------------------------------------*/
+
+#include "autoHexMeshDriver.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "boundBox.H"
+#include "globalIndex.H"
+#include "wallPolyPatch.H"
+#include "mapDistributePolyMesh.H"
+#include "cellSet.H"
+#include "syncTools.H"
+#include "motionSmoother.H"
+#include "pointMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(autoHexMeshDriver, 0);
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Check writing tolerance before doing any serious work
+Foam::scalar Foam::autoHexMeshDriver::getMergeDistance() const
+{
+    const scalar mergeTol = readScalar(dict_.lookup("mergeTolerance"));
+    const boundBox& meshBb = mesh_.bounds();
+    scalar mergeDist = mergeTol*mag(meshBb.max() - meshBb.min());
+    scalar writeTol = std::pow
+    (
+        scalar(10.0),
+       -scalar(IOstream::defaultPrecision())
+    );
+
+    Info<< "Overall mesh bounding box  : " << meshBb << nl
+        << "Relative tolerance         : " << mergeTol << nl
+        << "Absolute matching distance : " << mergeDist << nl
+        << endl;
+
+    if (mesh_.time().writeFormat() == IOstream::ASCII && mergeTol < writeTol)
+    {
+        FatalErrorIn("autoHexMeshDriver::getMergeDistance() const")
+            << "Your current settings specify ASCII writing with "
+            << IOstream::defaultPrecision() << " digits precision." << endl
+            << "Your merging tolerance (" << mergeTol << ") is finer than this."
+            << endl
+            << "Please change your writeFormat to binary"
+            << " or increase the writePrecision" << endl
+            << "or adjust the merge tolerance (-mergeTol)."
+            << exit(FatalError);
+    }
+
+    return mergeDist;
+}
+
+
+// Return per keeppoint -1 or the local cell label the point is in. Guaranteed
+// to be only on one processor.
+Foam::labelList Foam::autoHexMeshDriver::findCells(const pointField& keepPoints)
+ const
+{
+    // Global calculation engine
+    globalIndex globalCells(mesh_.nCells());
+
+    // Cell label per point
+    labelList cellLabels(keepPoints.size());
+
+    forAll(keepPoints, i)
+    {
+        const point& keepPoint = keepPoints[i];
+
+        label localCellI = mesh_.findCell(keepPoint);
+
+        label globalCellI = -1;
+
+        if (localCellI != -1)
+        {
+            Pout<< "Found point " << keepPoint << " in cell " << localCellI
+                << " on processor " << Pstream::myProcNo() << endl;
+            globalCellI = globalCells.toGlobal(localCellI);
+        }
+
+        reduce(globalCellI, maxOp<label>());
+
+        if (globalCellI == -1)
+        {
+            FatalErrorIn
+            (
+                "autoHexMeshDriver::findCells(const pointField&) const"
+            )   << "Point " << keepPoint << " is not inside the mesh." << nl
+                << "Bounding box of the mesh:" << mesh_.bounds()
+                << exit(FatalError);
+        }
+
+        if (globalCells.isLocal(globalCellI))
+        {
+            cellLabels[i] = localCellI;
+        }
+        else
+        {
+            cellLabels[i] = -1;
+        }
+    }
+    return cellLabels;
+}
+
+
+// Specifically orient using a calculated point outside
+void Foam::autoHexMeshDriver::orientOutside(PtrList<searchableSurface>& shells)
+{
+    // Determine outside point.
+    boundBox overallBb
+    (
+        point(GREAT, GREAT, GREAT),
+        point(-GREAT, -GREAT, -GREAT)
+    );
+
+    bool hasSurface = false;
+
+    forAll(shells, shellI)
+    {
+        if (isA<triSurfaceMesh>(shells[shellI]))
+        {
+            const triSurfaceMesh& shell =
+                refCast<const triSurfaceMesh>(shells[shellI]);
+
+            hasSurface = true;
+
+            boundBox shellBb(shell.localPoints(), false);
+
+            overallBb.min() = min(overallBb.min(), shellBb.min());
+            overallBb.max() = max(overallBb.max(), shellBb.max());
+        }
+    }
+
+    if (hasSurface)
+    {
+        const point outsidePt(2*overallBb.max() - overallBb.min());
+
+        //Info<< "Using point " << outsidePt << " to orient shells" << endl;
+
+        forAll(shells, shellI)
+        {
+            if (isA<triSurfaceMesh>(shells[shellI]))
+            {
+                triSurfaceMesh& shell = refCast<triSurfaceMesh>(shells[shellI]);
+
+                if (!refinementSurfaces::isSurfaceClosed(shell))
+                {
+                    FatalErrorIn("orientOutside(PtrList<searchableSurface>&)")
+                        << "Refinement shell "
+                        << shell.searchableSurface::name()
+                        << " is not closed." << exit(FatalError);
+                }
+
+                refinementSurfaces::orientSurface(outsidePt, shell);
+            }
+        }
+    }
+}
+
+
+// Check that face zones are synced
+void Foam::autoHexMeshDriver::checkCoupledFaceZones() const
+{
+    const faceZoneMesh& fZones = mesh_.faceZones();
+
+    // Check any zones are present anywhere and in same order
+
+    {
+        List<wordList> zoneNames(Pstream::nProcs());
+        zoneNames[Pstream::myProcNo()] = fZones.names();
+        Pstream::gatherList(zoneNames);
+        Pstream::scatterList(zoneNames);
+        // All have same data now. Check.
+        forAll(zoneNames, procI)
+        {
+            if (procI != Pstream::myProcNo())
+            {
+                if (zoneNames[procI] != zoneNames[Pstream::myProcNo()])
+                {
+                    FatalErrorIn
+                    (
+                        "autoHexMeshDriver::checkCoupledFaceZones() const"
+                    )   << "faceZones are not synchronised on processors." << nl
+                        << "Processor " << procI << " has faceZones "
+                        << zoneNames[procI] << nl
+                        << "Processor " << Pstream::myProcNo()
+                        << " has faceZones "
+                        << zoneNames[Pstream::myProcNo()] << nl
+                        << exit(FatalError);
+                }
+            }
+        }
+    }
+
+    // Check that coupled faces are present on both sides.
+
+    labelList faceToZone(mesh_.nFaces()-mesh_.nInternalFaces(), -1);
+
+    forAll(fZones, zoneI)
+    {
+        const faceZone& fZone = fZones[zoneI];
+
+        forAll(fZone, i)
+        {
+            label bFaceI = fZone[i]-mesh_.nInternalFaces();
+
+            if (bFaceI >= 0)
+            {
+                if (faceToZone[bFaceI] == -1)
+                {
+                    faceToZone[bFaceI] = zoneI;
+                }
+                else if (faceToZone[bFaceI] == zoneI)
+                {
+                    FatalErrorIn
+                    (
+                        "autoHexMeshDriver::checkCoupledFaceZones()"
+                    )   << "Face " << fZone[i] << " in zone "
+                        << fZone.name()
+                        << " is twice in zone!"
+                        << abort(FatalError);
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "autoHexMeshDriver::checkCoupledFaceZones()"
+                    )   << "Face " << fZone[i] << " in zone "
+                        << fZone.name()
+                        << " is also in zone "
+                        << fZones[faceToZone[bFaceI]].name()
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    labelList neiFaceToZone(faceToZone);
+    syncTools::swapBoundaryFaceList(mesh_, neiFaceToZone, false);
+
+    forAll(faceToZone, i)
+    {
+        if (faceToZone[i] != neiFaceToZone[i])
+        {
+            FatalErrorIn
+            (
+                "autoHexMeshDriver::checkCoupledFaceZones()"
+            )   << "Face " << mesh_.nInternalFaces()+i
+                << " is in zone " << faceToZone[i]
+                << ", its coupled face is in zone " << neiFaceToZone[i]
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+Foam::autoHexMeshDriver::autoHexMeshDriver
+(
+    fvMesh& mesh,
+    const dictionary& dict,
+    const dictionary& decomposeDict
+)
+:
+    mesh_(mesh),
+    dict_(dict),
+    debug_(readLabel(dict_.lookup("debug"))),
+    maxGlobalCells_(readLabel(dict_.lookup("cellLimit"))),
+    maxLocalCells_(readLabel(dict_.lookup("procCellLimit"))),
+    minRefineCells_(readLabel(dict_.lookup("minimumRefine"))),
+    curvature_(readScalar(dict_.lookup("curvature"))),
+    nBufferLayers_(readLabel(dict_.lookup("nBufferLayers"))),
+    keepPoints_(dict_.lookup("keepPoints")),
+    mergeDist_(getMergeDistance())
+{
+
+    if (debug_ > 0)
+    {
+        meshRefinement::debug = debug_;
+        autoHexMeshDriver::debug = debug_;
+    }
+
+    Info<< "Overall cell limit                         : " << maxGlobalCells_
+        << endl;
+    Info<< "Per processor cell limit                   : " << maxLocalCells_
+        << endl;
+    Info<< "Minimum number of cells to refine          : " << minRefineCells_
+        << endl;
+    Info<< "Curvature                                  : " << curvature_
+        << nl << endl;
+    Info<< "Layers between different refinement levels : " << nBufferLayers_
+        << endl;
+
+    // Check keepPoints are sensible
+    findCells(keepPoints_);
+
+
+    // Read refinement shells
+    // ~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        Info<< "Reading refinement shells." << endl;
+
+        PtrList<dictionary> shellDicts(dict_.lookup("refinementShells"));
+
+        shells_.setSize(shellDicts.size());
+        shellLevels_.setSize(shellDicts.size());
+        shellRefineInside_.setSize(shellDicts.size());
+
+        forAll(shellDicts, i)
+        {
+            const dictionary& dict = shellDicts[i];
+
+            shells_.set
+            (
+                i,
+                searchableSurface::New
+                (
+                    dict.lookup("type"),
+                    dict.lookup("name"),
+                    mesh_.time(),
+                    dict
+                )
+            );
+            shellLevels_[i] = readLabel(dict.lookup("level"));
+            shellRefineInside_[i] = Switch(dict.lookup("refineInside"));
+
+            if (shellRefineInside_[i])
+            {
+                Info<< "Refinement level " << shellLevels_[i]
+                    << " for all cells inside " << shells_[i].name() << endl;
+            }
+            else
+            {
+                Info<< "Refinement level " << shellLevels_[i]
+                    << " for all cells outside " << shells_[i].name() << endl;
+            }
+        }
+
+        Info<< "Read refinement shells in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        // Orient shell surfaces before any searching is done.
+        Info<< "Orienting triSurface shells so point far away is outside."
+            << endl;
+        orientOutside(shells_);
+        Info<< "Oriented shells in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
+
+
+    // Read refinement surfaces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        Info<< "Reading surfaces and constructing search trees." << endl;
+
+        surfacesPtr_.reset
+        (
+            new refinementSurfaces
+            (
+                IOobject
+                (
+                    "",                                 // dummy name
+                    mesh_.time().constant(),            // directory
+                    "triSurface",                       // instance
+                    mesh_.time(),                       // registry
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                dict_.lookup("surfaces")
+            )
+        );
+        Info<< "Read surfaces in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        // Orient surfaces (if they're closed) before any searching is done.
+        Info<< "Orienting (closed) surfaces so keepPoint is outside." << endl;
+        forAll(surfaces(), i)
+        {
+            if (refinementSurfaces::isSurfaceClosed(surfaces()[i]))
+            {
+                refinementSurfaces::orientSurface
+                (
+                    keepPoints_[0],
+                    surfacesPtr_()[i]
+                );
+            }
+        }
+        Info<< "Oriented closed surfaces in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        Info<< "Setting refinement level of surface to be consistent"
+            << " with shells." << endl;
+        surfacesPtr_().setMinLevelFields
+        (
+            shells_,
+            shellLevels_,
+            shellRefineInside_
+        );
+        Info<< "Checked shell refinement in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
+
+    // Check faceZones are synchronised
+    checkCoupledFaceZones();
+
+
+    // Add all the surface regions as patches
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        Info<< nl
+            << "Adding patches for surface regions" << nl
+            << "----------------------------------" << nl
+            << endl;
+
+        // From global region number to mesh patch.
+        globalToPatch_.setSize(surfaces().nRegions(), -1);
+
+        Info<< "Patch\tRegion" << nl
+            << "-----\t------"
+            << endl;
+
+        forAll(surfaces(), surfI)
+        {
+            const triSurfaceMesh& s = surfaces()[surfI];
+
+            Info<< surfaces().names()[surfI] << ':' << nl << nl;
+
+            const geometricSurfacePatchList& regions = s.patches();
+
+            labelList nTrisPerRegion(surfaces().countRegions(s));
+
+            forAll(regions, i)
+            {
+                if (nTrisPerRegion[i] > 0)
+                {
+                    label patchI = meshRefinement::addPatch
+                    (
+                        mesh,
+                        //s.searchableSurface::name() + '_' + regions[i].name(),
+                        surfaces().names()[surfI] + '_' + regions[i].name(),
+                        wallPolyPatch::typeName
+                    );
+
+                    Info<< patchI << '\t' << regions[i].name() << nl;
+
+                    globalToPatch_[surfaces().globalRegion(surfI, i)] = patchI;
+                }
+            }
+
+            Info<< nl;
+        }
+        Info<< "Added patches in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
+
+
+    //// Add cyclics for any named faceZones
+    //// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //// (these cyclics are used later on to temporarily put the faceZones
+    ////  in when snapping)
+    //
+    //labelList namedSurfaces(surfaces().getNamedSurfaces());
+    //if (namedSurfaces.size() > 0)
+    //{
+    //    Info<< nl
+    //        << "Introducing cyclics for faceZones" << nl
+    //        << "---------------------------------" << nl
+    //        << endl;
+    //
+    //    // From surface to cyclic patch
+    //    surfaceToCyclicPatch_.setSize(surfaces().size(), -1);
+    //
+    //    Info<< "Patch\tZone" << nl
+    //        << "----\t-----"
+    //        << endl;
+    //
+    //    forAll(namedSurfaces, i)
+    //    {
+    //        label surfI = namedSurfaces[i];
+    //
+    //        surfaceToCyclicPatch_[surfI] = meshRefinement::addPatch
+    //        (
+    //            mesh,
+    //            surfaces().faceZoneNames()[surfI],
+    //            cyclicPolyPatch::typeName
+    //        );
+    //
+    //        Info<< surfaceToCyclicPatch_[surfI] << '\t'
+    //            << surfaces().faceZoneNames()[surfI] << nl << endl;
+    //    }
+    //    Info<< "Added cyclic patches in = "
+    //        << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    //}
+
+
+    // Parallel
+    // ~~~~~~~~
+
+    {
+        // Decomposition
+        decomposerPtr_ = decompositionMethod::New
+        (
+            decomposeDict,
+            mesh_
+        );
+        decompositionMethod& decomposer = decomposerPtr_();
+
+
+        if (Pstream::parRun() && !decomposer.parallelAware())
+        {
+            FatalErrorIn("autoHexMeshDriver::autoHexMeshDriver(const IOobject&, fvMesh&)")
+                << "You have selected decomposition method "
+                << decomposer.typeName
+                << " which is not parallel aware." << endl
+                << "Please select one that is (parMetis, hierarchical)"
+                << exit(FatalError);
+        }
+
+        // Mesh distribution engine (uses tolerance to reconstruct meshes)
+        distributorPtr_.reset(new fvMeshDistribute(mesh_, mergeDist_));
+    }
+
+
+    // Refinement engine
+    // ~~~~~~~~~~~~~~~~~
+
+    {
+        Info<< nl
+            << "Determining initial surface intersections" << nl
+            << "-----------------------------------------" << nl
+            << endl;
+
+        // Main refinement engine
+        meshRefinerPtr_.reset
+        (
+            new meshRefinement
+            (
+                mesh,
+                mergeDist_,         // tolerance used in sorting coordinates
+                surfaces()
+            )
+        );
+        Info<< "Calculated surface intersections in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        // Some stats
+        meshRefinerPtr_().printMeshInfo(debug_, "Initial mesh");
+
+        meshRefinerPtr_().write
+        (
+            debug_&meshRefinement::OBJINTERSECTIONS,
+            mesh_.time().path()/mesh_.time().timeName()
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Read explicit feature edges
+Foam::label Foam::autoHexMeshDriver::readFeatureEdges()
+{
+    Info<< "Reading external feature lines." << endl;
+
+    PtrList<dictionary> featDicts(dict_.lookup("features"));
+
+    featureMeshes_.setSize(featDicts.size());
+    featureLevels_.setSize(featDicts.size());
+
+    forAll(featDicts, i)
+    {
+        const dictionary& dict = featDicts[i];
+
+        fileName featFileName(dict.lookup("file"));
+
+        featureMeshes_.set
+        (
+            i,
+            new featureEdgeMesh
+            (
+                IOobject
+                (
+                    featFileName,           // name
+                    mesh_.time().constant(),// directory
+                    "triSurface",           // instance
+                    mesh_.db(),             // registry
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                )
+            )
+        );
+
+        featureMeshes_[i].mergePoints(mergeDist_);
+        featureLevels_[i] = readLabel(dict.lookup("level"));
+
+        Info<< "Refinement level " << featureLevels_[i]
+            << " for all cells crossed by feature " << featFileName
+            << " (" << featureMeshes_[i].points().size() << " points, "
+            << featureMeshes_[i].edges().size() << ")." << endl;
+    }
+
+    Info<< "Read feature lines in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+    return featureMeshes_.size();
+}
+
+
+Foam::label Foam::autoHexMeshDriver::featureEdgeRefine
+(
+    const label maxIter,
+    const label minRefine
+)
+{
+    // Read explicit feature edges
+    readFeatureEdges();
+
+
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    label iter = 0;
+
+    if (featureMeshes_.size() > 0 && maxIter > 0)
+    {
+        for (; iter < maxIter; iter++)
+        {
+            Info<< nl
+                << "Feature refinement iteration " << iter << nl
+                << "------------------------------" << nl
+                << endl;
+
+            labelList candidateCells
+            (
+                meshRefiner.refineCandidates
+                (
+                    keepPoints_[0],     // For now only use one.
+                    globalToPatch_,
+                    curvature_,
+
+                    featureMeshes_,
+                    featureLevels_,
+
+                    shells_,
+                    shellLevels_,
+                    shellRefineInside_,
+
+                    true,               // featureRefinement
+                    false,              // internalRefinement
+                    false,              // surfaceRefinement
+                    false,              // curvatureRefinement
+                    maxGlobalCells_,
+                    maxLocalCells_
+                )
+            );
+            labelList cellsToRefine
+            (
+                meshRefiner.meshCutter().consistentRefinement
+                (
+                    candidateCells,
+                    true
+                )
+            );
+            Info<< "Determined cells to refine in = "
+                << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+
+
+            label nCellsToRefine = cellsToRefine.size();
+            reduce(nCellsToRefine, sumOp<label>());
+
+            Info<< "Selected for feature refinement : " << nCellsToRefine
+                << " cells (out of " << mesh_.globalData().nTotalCells()
+                << ')' << endl;
+
+            if (nCellsToRefine <= minRefine)
+            {
+                Info<< "Stopping refining since too few cells selected."
+                    << nl << endl;
+                break;
+            }
+
+
+            if (debug_ > 0)
+            {
+                const_cast<Time&>(mesh_.time())++;
+            }
+
+            meshRefiner.refineAndBalance
+            (
+                "feature refinement iteration " + name(iter),
+                decomposerPtr_(),
+                distributorPtr_(),
+                cellsToRefine
+            );
+        }
+    }
+    return iter;
+}
+
+
+Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine(const label maxIter)
+{
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    // Determine the maximum refinement level over all surfaces. This
+    // determines the minumum number of surface refinement iterations.
+    label overallMaxLevel = max(surfaces().maxLevel());
+
+    label iter;
+    for (iter = 0; iter < maxIter; iter++)
+    {
+        Info<< nl
+            << "Surface refinement iteration " << iter << nl
+            << "------------------------------" << nl
+            << endl;
+
+
+        // Determine cells to refine
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Only look at surface intersections (minLevel and surface curvature),
+        // do not do internal refinement (refinementShells)
+
+        labelList candidateCells
+        (
+            meshRefiner.refineCandidates
+            (
+                keepPoints_[0],
+                globalToPatch_,
+                curvature_,
+
+                featureMeshes_,
+                featureLevels_,
+
+                shells_,
+                shellLevels_,
+                shellRefineInside_,
+
+                false,              // featureRefinement
+                false,              // internalRefinement
+                true,               // surfaceRefinement
+                true,               // curvatureRefinement
+                maxGlobalCells_,
+                maxLocalCells_
+            )
+        );
+        labelList cellsToRefine
+        (
+            meshRefiner.meshCutter().consistentRefinement
+            (
+                candidateCells,
+                true
+            )
+        );
+        Info<< "Determined cells to refine in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+
+        label nCellsToRefine = cellsToRefine.size();
+        reduce(nCellsToRefine, sumOp<label>());
+
+        Info<< "Selected for refinement : " << nCellsToRefine
+            << " cells (out of " << mesh_.globalData().nTotalCells()
+            << ')' << endl;
+
+        // Stop when no cells to refine or have done minimum nessecary
+        // iterations and not enough cells to refine.
+        if
+        (
+            nCellsToRefine == 0
+         || (
+                iter >= overallMaxLevel
+             && nCellsToRefine <= minRefineCells_
+            )
+        )
+        {
+            Info<< "Stopping refining since too few cells selected."
+                << nl << endl;
+            break;
+        }
+
+
+        if (debug_)
+        {
+            const_cast<Time&>(mesh_.time())++;
+        }
+
+        meshRefiner.refineAndBalance
+        (
+            "surface refinement iteration " + name(iter),
+            decomposerPtr_(),
+            distributorPtr_(),
+            cellsToRefine
+        );
+    }
+    return iter;
+}
+
+
+void Foam::autoHexMeshDriver::removeInsideCells(const label nBufferLayers)
+{
+
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    Info<< nl
+        << "Removing mesh beyond surface intersections" << nl
+        << "------------------------------------------" << nl
+        << endl;
+
+    if (debug_)
+    {
+       const_cast<Time&>(mesh_.time())++;
+    }
+
+    meshRefiner.splitMesh
+    (
+        nBufferLayers,                  // nBufferLayers
+        globalToPatch_,
+        keepPoints_[0]
+    );
+
+    if (debug_)
+    {
+        Pout<< "Writing subsetted mesh to time "
+            << mesh_.time().timeName() << '.' << endl;
+        meshRefiner.write(debug_, mesh_.time().path()/mesh_.time().timeName());
+        Pout<< "Dumped mesh in = "
+            << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+}
+
+
+Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
+{
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+
+    // Mark current boundary faces with 0. Have meshRefiner maintain them.
+    meshRefiner.userFaceData().setSize(1);
+
+    // mark list to remove any refined faces
+    meshRefiner.userFaceData()[0].first() = meshRefinement::REMOVE;
+    meshRefiner.userFaceData()[0].second() = createWithValues<labelList>
+    (
+        mesh_.nFaces(),
+        -1,
+        meshRefiner.intersectedFaces(),
+        0
+    );
+
+    // Determine the maximum refinement level over all volume refinement
+    // regions. This determines the minumum number of shell refinement
+    // iterations.
+    label overallMaxShellLevel;
+    if (shellLevels_.size() == 0)
+    {
+        overallMaxShellLevel = 0;
+    }
+    else
+    {
+        overallMaxShellLevel = max(shellLevels_);
+    }
+
+    label iter;
+    for (iter = 0; iter < maxIter; iter++)
+    {
+        Info<< nl
+            << "Shell refinement iteration " << iter << nl
+            << "----------------------------" << nl
+            << endl;
+
+        labelList candidateCells
+        (
+            meshRefiner.refineCandidates
+            (
+                keepPoints_[0],
+                globalToPatch_,
+                curvature_,
+
+                featureMeshes_,
+                featureLevels_,
+
+                shells_,
+                shellLevels_,
+                shellRefineInside_,
+
+                false,              // featureRefinement
+                true,               // internalRefinement
+                false,              // surfaceRefinement
+                false,              // curvatureRefinement
+                maxGlobalCells_,
+                maxLocalCells_
+            )
+        );
+
+        if (debug_)
+        {
+            Pout<< "Dumping " << candidateCells.size()
+                << " cells to cellSet candidateCellsFromShells." << endl;
+
+            cellSet(mesh_, "candidateCellsFromShells", candidateCells).write();
+        }
+
+        // Problem choosing starting faces for bufferlayers (bFaces)
+        //  - we can't use the current intersected boundary faces
+        //    (intersectedFaces) since this grows indefinitely
+        //  - if we use 0 faces we don't satisfy bufferLayers from the
+        //    surface.
+        //  - possibly we want to have bFaces only the initial set of faces
+        //    and maintain the list while doing the refinement.
+        labelList bFaces
+        (
+            findIndices(meshRefiner.userFaceData()[0].second(), 0)
+        );
+
+        Info<< "Collected boundary faces : "
+            << returnReduce(bFaces.size(), sumOp<label>()) << endl;
+
+        labelList cellsToRefine;
+
+        if (nBufferLayers_ <= 2)
+        {
+            cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement
+            (
+                nBufferLayers_,
+                candidateCells,                 // cells to refine
+                bFaces,                         // faces for nBufferLayers
+                1,                              // point difference
+                meshRefiner.intersectedPoints() // points to check
+            );
+        }
+        else
+        {
+            cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement2
+            (
+                nBufferLayers_,
+                candidateCells,                 // cells to refine
+                bFaces                          // faces for nBufferLayers
+            );
+        }
+
+        Info<< "Determined cells to refine in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+
+        label nCellsToRefine = cellsToRefine.size();
+        reduce(nCellsToRefine, sumOp<label>());
+
+        Info<< "Selected for internal refinement : " << nCellsToRefine
+            << " cells (out of " << mesh_.globalData().nTotalCells()
+            << ')' << endl;
+
+        // Stop when no cells to refine or have done minimum nessecary
+        // iterations and not enough cells to refine.
+        if
+        (
+            nCellsToRefine == 0
+         || (
+                iter >= overallMaxShellLevel
+             && nCellsToRefine <= minRefineCells_
+            )
+        )
+        {
+            Info<< "Stopping refining since too few cells selected."
+                << nl << endl;
+            break;
+        }
+
+
+        if (debug_)
+        {
+            const_cast<Time&>(mesh_.time())++;
+        }
+
+        meshRefiner.refineAndBalance
+        (
+            "shell refinement iteration " + name(iter),
+            decomposerPtr_(),
+            distributorPtr_(),
+            cellsToRefine
+        );
+    }
+    meshRefiner.userFaceData().clear();
+
+    return iter;
+}
+
+
+void Foam::autoHexMeshDriver::baffleAndSplitMesh(const bool handleSnapProblems)
+{
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    Info<< nl
+        << "Splitting mesh at surface intersections" << nl
+        << "---------------------------------------" << nl
+        << endl;
+
+    // Introduce baffles at surface intersections. Note:
+    // meshRefiment::surfaceIndex() will
+    // be like boundary face from now on so not coupled anymore.
+    meshRefiner.baffleAndSplitMesh
+    (
+        handleSnapProblems,
+        !handleSnapProblems,            // merge free standing baffles?
+        const_cast<Time&>(mesh_.time()),
+        globalToPatch_,
+        keepPoints_[0]
+    );
+}
+
+
+void Foam::autoHexMeshDriver::zonify()
+{
+    // Mesh is at its finest. Do zoning
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // This puts all faces with intersection across a zoneable surface
+    // into that surface's faceZone. All cells inside faceZone get given the
+    // same cellZone.
+
+
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    if (surfaces().getNamedSurfaces().size() > 0)
+    {
+        Info<< nl
+            << "Introducing zones for interfaces" << nl
+            << "--------------------------------" << nl
+            << endl;
+
+        if (debug_)
+        {
+            const_cast<Time&>(mesh_.time())++;
+        }
+
+        meshRefiner.zonify(keepPoints_[0]);
+
+        if (debug_)
+        {
+            Pout<< "Writing zoned mesh to time "
+                << mesh_.time().timeName() << '.' << endl;
+            meshRefiner.write
+            (
+                debug_,
+                mesh_.time().path()/mesh_.time().timeName()
+            );
+        }
+
+        // Check that all faces are synced
+        checkCoupledFaceZones();
+    }
+}
+
+
+void Foam::autoHexMeshDriver::splitAndMergeBaffles
+(
+    const bool handleSnapProblems
+)
+{
+    Info<< nl
+        << "Handling cells with snap problems" << nl
+        << "---------------------------------" << nl
+        << endl;
+
+    // Introduce baffles and split mesh
+    if (debug_)
+    {
+        const_cast<Time&>(mesh_.time())++;
+    }
+
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    meshRefiner.baffleAndSplitMesh
+    (
+        handleSnapProblems,
+        false,                  // merge free standing baffles?
+        const_cast<Time&>(mesh_.time()),
+        globalToPatch_,
+        keepPoints_[0]
+    );
+
+
+    // Duplicate points on baffles that are on more than one cell
+    // region. This will help snapping pull them to separate surfaces.
+    meshRefiner.dupNonManifoldPoints();
+
+
+    // Merge all baffles that are still remaining after duplicating points.
+    List<labelPair> couples
+    (
+        meshRefiner.getDuplicateFaces   // get all baffles
+        (
+            identity(mesh_.nFaces()-mesh_.nInternalFaces())
+           +mesh_.nInternalFaces()
+        )
+    );
+
+    label nCouples = returnReduce(couples.size(), sumOp<label>());
+
+    Info<< "Detected unsplittable baffles : "
+        << nCouples << endl;
+
+    if (nCouples > 0)
+    {
+        // Actually merge baffles. Note: not exactly parallellized. Should
+        // convert baffle faces into processor faces if they resulted
+        // from them.
+        meshRefiner.mergeBaffles(couples);
+
+        if (debug_)
+        {
+            // Debug:test all is still synced across proc patches
+            meshRefiner.checkData();
+        }
+        Info<< "Merged free-standing baffles in = "
+            << mesh_.time().cpuTimeIncrement() << " s." << endl;
+    }
+
+    if (debug_)
+    {
+        Pout<< "Writing handleProblemCells mesh to time "
+            << mesh_.time().timeName() << '.' << endl;
+        meshRefiner.write(debug_, mesh_.time().path()/mesh_.time().timeName());
+    }
+}
+
+
+void Foam::autoHexMeshDriver::mergePatchFaces()
+{
+    Info<< nl
+        << "Merge refined boundary faces" << nl
+        << "----------------------------" << nl
+        << endl;
+
+    if (debug_)
+    {
+        const_cast<Time&>(mesh_.time())++;
+    }
+
+    meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    meshRefiner.mergePatchFaces
+    (
+        Foam::cos(45*mathematicalConstant::pi/180.0),
+        Foam::cos(45*mathematicalConstant::pi/180.0)
+    );
+
+    if (debug_)
+    {
+        meshRefiner.checkData();
+    }
+
+    meshRefiner.mergeEdges(Foam::cos(45*mathematicalConstant::pi/180.0));
+
+    if (debug_)
+    {
+        meshRefiner.checkData();
+    }
+}
+
+
+Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::autoHexMeshDriver::balance
+(
+    const bool keepZoneFaces,
+    const bool keepBaffles
+)
+{
+    autoPtr<mapDistributePolyMesh> map;
+
+    if (Pstream::parRun())
+    {
+        Info<< nl
+            << "Doing final balancing" << nl
+            << "---------------------" << nl
+            << endl;
+
+        if (debug_)
+        {
+            const_cast<Time&>(mesh_.time())++;
+        }
+
+        meshRefinement& meshRefiner = meshRefinerPtr_();
+        decompositionMethod& decomposer = decomposerPtr_();
+        fvMeshDistribute& distributor = distributorPtr_();
+
+        // Wanted distribution
+        labelList distribution;
+
+        if (keepZoneFaces || keepBaffles)
+        {
+            // Faces where owner and neighbour are not 'connected' so can
+            // go to different processors.
+            boolList blockedFace(mesh_.nFaces(), true);
+            // Pairs of baffles
+            List<labelPair> couples;
+
+            if (keepZoneFaces)
+            {
+                label nNamed = surfaces().getNamedSurfaces().size();
+
+                Info<< "Found " << nNamed << " surfaces with faceZones."
+                    << " Applying special decomposition to keep those together."
+                    << endl;
+
+                // Determine decomposition to keep/move surface zones
+                // on one processor. The reason is that snapping will make these
+                // into baffles, move and convert them back so if they were
+                // proc boundaries after baffling&moving the points might be no
+                // longer snychronised so recoupling will fail. To prevent this
+                // keep owner&neighbour of such a surface zone on the same
+                // processor.
+
+                const wordList& fzNames = surfaces().faceZoneNames();
+                const faceZoneMesh& fZones = mesh_.faceZones();
+
+                // Get faces whose owner and neighbour should stay together, i.e.
+                // they are not 'blocked'.
+
+                label nZoned = 0;
+
+                forAll(fzNames, surfI)
+                {
+                    if (fzNames[surfI].size() > 0)
+                    {
+                        // Get zone
+                        label zoneI = fZones.findZoneID(fzNames[surfI]);
+
+                        const faceZone& fZone = fZones[zoneI];
+
+                        forAll(fZone, i)
+                        {
+                            if (blockedFace[fZone[i]])
+                            {
+                                blockedFace[fZone[i]] = false;
+                                nZoned++;
+                            }
+                        }
+                    }
+                }
+                Info<< "Found " << returnReduce(nZoned, sumOp<label>())
+                    << " zoned faces to keep together."
+                    << endl;
+            }
+
+            if (keepBaffles)
+            {
+                // Get boundary baffles that need to stay together.
+                couples =  meshRefiner.getDuplicateFaces   // all baffles
+                (
+                    identity(mesh_.nFaces()-mesh_.nInternalFaces())
+                   +mesh_.nInternalFaces()
+                );
+
+                Info<< "Found " << returnReduce(couples.size(), sumOp<label>())
+                    << " baffles to keep together."
+                    << endl;
+            }
+
+            distribution = meshRefiner.decomposeCombineRegions
+            (
+                blockedFace,
+                couples,
+                decomposer
+            );
+
+            labelList nProcCells(distributor.countCells(distribution));
+            Pstream::listCombineGather(nProcCells, plusEqOp<label>());
+            Pstream::listCombineScatter(nProcCells);
+
+            Info<< "Calculated decomposition:" << endl;
+            forAll(nProcCells, procI)
+            {
+                Info<< "    " << procI << '\t' << nProcCells[procI] << endl;
+            }
+            Info<< endl;
+        }
+        else
+        {
+            // Normal decomposition
+            distribution = decomposer.decompose(mesh_.cellCentres());
+        }
+
+        if (debug_)
+        {
+            Pout<< "Wanted distribution:"
+                << distributor.countCells(distribution)
+                << endl;
+        }
+        // Do actual sending/receiving of mesh
+        map = distributor.distribute(distribution);
+
+        // Update numbering of meshRefiner
+        meshRefiner.distribute(map);
+    }
+    return map;
+}
+
+
+void Foam::autoHexMeshDriver::writeMesh(const string& msg) const
+{
+    const meshRefinement& meshRefiner = meshRefinerPtr_();
+
+    meshRefiner.printMeshInfo(debug_, msg);
+    Info<< "Writing mesh to time " << mesh_.time().timeName() << endl;
+
+    meshRefiner.write(meshRefinement::MESH|meshRefinement::SCALARLEVELS, "");
+    if (debug_ & meshRefinement::OBJINTERSECTIONS)
+    {
+        meshRefiner.write
+        (
+            meshRefinement::OBJINTERSECTIONS,
+            mesh_.time().path()/mesh_.time().timeName()
+        );
+    }
+    Info<< "Written mesh in = "
+        << mesh_.time().cpuTimeIncrement() << " s." << endl;
+}
+
+
+void Foam::autoHexMeshDriver::doMesh()
+{
+    Switch doRefine(dict_.lookup("doRefine"));
+    Switch doSnap(dict_.lookup("doSnap"));
+    Switch doLayers(dict_.lookup("doLayers"));
+
+    Info<< "Do refinement : " << doRefine << nl
+        << "Do snapping   : " << doSnap << nl
+        << "Do layers     : " << doLayers << nl
+        << endl;
+
+    if (doRefine)
+    {
+        Info<< nl
+            << "Refinement phase" << nl
+            << "----------------" << nl
+            << endl;
+
+        const_cast<Time&>(mesh_.time())++;
+
+        // Refine around feature edges
+        featureEdgeRefine
+        (
+            100,    // maxIter
+            0       // min cells to refine
+        );
+
+        // Refine based on surface
+        surfaceOnlyRefine
+        (
+            100     // maxIter
+        );
+
+        // Remove cells (a certain distance) beyond surface intersections
+        removeInsideCells
+        (
+            1       // nBufferLayers
+        );
+
+        // Internal mesh refinement
+        shellRefine
+        (
+            100    // maxIter
+        );
+
+        // Introduce baffles at surface intersections
+        baffleAndSplitMesh(doSnap);
+
+        // Mesh is at its finest. Do optional zoning.
+        zonify();
+
+        // Pull baffles apart
+        splitAndMergeBaffles(doSnap);
+
+        // Do something about cells with refined faces on the boundary
+        if (doSnap)
+        {
+            mergePatchFaces();
+        }
+
+        // Do final balancing. Keep zoned faces on one processor.
+        balance(true, false);
+
+        // Write mesh
+        writeMesh("Refined mesh");
+    }
+
+
+    if (doSnap)
+    {
+        Info<< nl
+            << "Morphing phase" << nl
+            << "--------------" << nl
+            << endl;
+
+        const_cast<Time&>(mesh_.time())++;
+
+        // Get the labels of added patches.
+        labelList adaptPatchIDs(getSurfacePatches());
+
+        // Create baffles (pairs of faces that share the same points)
+        // Baffles stored as owner and neighbour face that have been created.
+        List<labelPair> baffles;
+        createZoneBaffles(baffles);
+
+        {
+            autoPtr<indirectPrimitivePatch> ppPtr
+            (
+                meshRefinement::makePatch
+                (
+                    mesh_,
+                    adaptPatchIDs
+                )
+            );
+            indirectPrimitivePatch& pp = ppPtr();
+
+            // Distance to attact to nearest feature on surface
+            const scalarField snapDist(calcSnapDistance(pp));
+
+
+            // Construct iterative mesh mover.
+            Info<< "Constructing mesh displacer ..." << endl;
+            const dictionary& motionDict = dict_.subDict("motionDict");
+            Info<< "Using mesh parameters " << motionDict << nl << endl;
+
+            pointMesh pMesh(mesh_);
+
+            motionSmoother meshMover
+            (
+                mesh_,
+                pp,
+                adaptPatchIDs,
+                meshRefinement::makeDisplacementField(pMesh, adaptPatchIDs),
+                motionDict
+            );
+
+
+            // Check initial mesh
+            Info<< "Checking initial mesh ..." << endl;
+            labelHashSet wrongFaces(mesh_.nFaces()/100);
+            motionSmoother::checkMesh(false, mesh_, motionDict, wrongFaces);
+            const label nInitErrors = returnReduce
+            (
+                wrongFaces.size(),
+                sumOp<label>()
+            );
+
+            Info<< "Detected " << nInitErrors << " illegal faces"
+                << " (concave, zero area or negative cell pyramid volume)"
+                << endl;
+
+
+            Info<< "Checked initial mesh in = "
+                << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+
+            // Pre-smooth patch vertices (so before determining nearest)
+            preSmoothPatch(nInitErrors, baffles, meshMover);
+
+            // Calculate displacement at every patch point. Insert into meshMover.
+            calcNearestSurface(snapDist, meshMover);
+
+            // Get smoothly varying internal displacement field.
+            smoothDisplacement(meshMover);
+
+            // Apply internal displacement to mesh.
+            scaleMesh(nInitErrors, baffles, meshMover);
+        }
+
+        // Merge any introduced baffles.
+        mergeZoneBaffles(baffles);
+
+        // Write mesh.
+        writeMesh("Snapped mesh");
+    }
+
+
+    if (doLayers)
+    {
+        Info<< nl
+            << "Shrinking and layer addition phase" << nl
+            << "----------------------------------" << nl
+            << endl;
+
+        const_cast<Time&>(mesh_.time())++;
+
+        // Merge coplanar boundary faces
+        mergePatchFacesUndo();
+
+        // Per global region the number of layers (0 if no layer)
+        labelList nLayers(readNumLayers());
+
+        // Patches that need to get a layer
+        DynamicList<label> patchIDs(nLayers.size());
+        label nFacesWithLayers = 0;
+        forAll(nLayers, region)
+        {
+            if (nLayers[region] > 0 && globalToPatch()[region] != -1)
+            {
+                label patchI = globalToPatch()[region];
+                patchIDs.append(patchI);
+                nFacesWithLayers += mesh_.boundaryMesh()[patchI].size();
+            }
+        }
+        patchIDs.shrink();
+
+        if (returnReduce(nFacesWithLayers, sumOp<label>()) == 0)
+        {
+            Info<< nl << "No layers to generate ..." << endl;
+        }
+        else
+        {
+            autoPtr<indirectPrimitivePatch> ppPtr
+            (
+                meshRefinement::makePatch
+                (
+                    mesh_,
+                    patchIDs
+                )
+            );
+            indirectPrimitivePatch& pp = ppPtr();
+
+            // Construct iterative mesh mover.
+            Info<< "Constructing mesh displacer ..." << endl;
+            const dictionary& motionDict = dict_.subDict("motionDict");
+            Info<< "Using mesh parameters " << motionDict << nl << endl;
+
+            {
+                pointMesh pMesh(mesh_);
+
+                motionSmoother meshMover
+                (
+                    mesh_,
+                    pp,
+                    patchIDs,
+                    meshRefinement::makeDisplacementField(pMesh, patchIDs),
+                    motionDict
+                );
+
+                // Check that outside of mesh is not multiply connected.
+                checkMeshManifold();
+
+                // Check initial mesh
+                Info<< "Checking initial mesh ..." << endl;
+                labelHashSet wrongFaces(mesh_.nFaces()/100);
+                motionSmoother::checkMesh(false, mesh_, motionDict, wrongFaces);
+                const label nInitErrors = returnReduce
+                (
+                    wrongFaces.size(),
+                    sumOp<label>()
+                );
+
+                Info<< "Detected " << nInitErrors << " illegal faces"
+                    << " (concave, zero area or negative cell pyramid volume)"
+                    << endl;
+
+
+                // Do all topo changes
+                addLayers(nInitErrors, meshMover);
+            }
+
+            // Write mesh.
+            writeMesh("Layer mesh");
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
new file mode 100644
index 0000000000..3ff2513f2c
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
@@ -0,0 +1,810 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    autoHexMeshDriver
+
+Description
+    main meshing driver.
+
+SourceFiles
+    autoHexMeshDriver.C
+    autoHexMeshDriverSnap.C
+    autoHexMeshDriverLayers.C
+    autoHexMeshDriverShrink.C
+    autoHexMeshDriverTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef autoHexMeshDriver_H
+#define autoHexMeshDriver_H
+
+#include "autoPtr.H"
+#include "dictionary.H"
+#include "pointField.H"
+#include "boolList.H"
+#include "Switch.H"
+#include "PackedList.H"
+#include "wallPoint.H"
+#include "indirectPrimitivePatch.H"
+#include "featureEdgeMesh.H"
+#include "searchableSurface.H"
+#include "refinementSurfaces.H"
+#include "meshRefinement.H"
+#include "decompositionMethod.H"
+#include "fvMeshDistribute.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class fvMesh;
+class pointMesh;
+class motionSmoother;
+class removePoints;
+class pointSet;
+class pointData;
+class faceSet;
+class addPatchCellLayer;
+class mapDistributePolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class autoHexMeshDriver Declaration
+\*---------------------------------------------------------------------------*/
+
+class autoHexMeshDriver
+{
+    // Static data members
+
+        //- Default angle for faces to be convcave
+        static const scalar defaultConcaveAngle;
+
+        //- Extrusion controls
+        enum extrudeMode
+        {
+            NOEXTRUDE,      // Do not extrude. No layers added.
+            EXTRUDE,        // Extrude
+            EXTRUDEREMOVE   // Extrude but afterwards remove added faces locally
+        };
+
+
+    // Private classes
+
+        //- Combine operator class for equalizing displacements.
+        class minMagEqOp
+        {
+        public:
+
+            void operator()(vector& x, const vector& y) const
+            {
+                if (magSqr(y) < magSqr(x))
+                {
+                    x = y;
+                }
+            }
+        };
+
+        // Combine operator class to combine normal with other normal.
+        class nomalsCombine
+        {
+        public:
+
+            void operator()(vector& x, const vector& y) const
+            {
+                if (y != wallPoint::greatPoint)
+                {
+                    if (x == wallPoint::greatPoint)
+                    {
+                        x = y;
+                    }
+                    else
+                    {
+                        x *= (x&y);
+                    }
+                }
+            }
+        };
+
+
+
+    // Private data
+
+        //- Reference to mesh
+        fvMesh& mesh_;
+
+        //- Input dictionarys
+        const dictionary dict_;
+
+        //- Debug level
+        const label debug_;
+
+        //- Total number of cells
+        const label maxGlobalCells_;
+
+        //- Per processor max number of cells
+        const label maxLocalCells_;
+
+        //- When to stop refining
+        const label minRefineCells_;
+
+        //- Curvature
+        const scalar curvature_;
+
+        //- Number of layers between different refinement levels
+        const label nBufferLayers_;
+
+        //- Areas to keep
+        const pointField keepPoints_;
+
+        //- Merge distance
+        const scalar mergeDist_;
+
+
+
+
+        //- Explicit features
+        PtrList<featureEdgeMesh> featureMeshes_;
+        //- Per feature the refinement level
+        labelList featureLevels_;
+
+        //- Shells
+        PtrList<searchableSurface> shells_;
+        //- Per shell the refinement level
+        labelList shellLevels_;
+        //- Per shell whether to refine inside or outside
+        boolList shellRefineInside_;
+
+        //- Surfaces with refinement levels built-in
+        autoPtr<refinementSurfaces> surfacesPtr_;
+
+        //- Per refinement surface region the patch
+        labelList globalToPatch_;
+
+        ////- Per refinement surface with a valid faceZone the cyclicpatch
+        ////  (or -1)
+        //labelList surfaceToCyclicPatch_;
+
+        //- Mesh refinement engine
+        autoPtr<meshRefinement> meshRefinerPtr_;
+
+        //- Decomposition engine
+        autoPtr<decompositionMethod> decomposerPtr_;
+
+        //- Mesh distribution engine
+        autoPtr<fvMeshDistribute> distributorPtr_;
+
+
+    // Private Member Functions
+
+        // Refinement
+
+            //- Get merge tolerance. Check against writing tolerance.
+            scalar getMergeDistance() const;
+
+            // Return per keeppoint -1 or the local cell label the point is in.
+            // Guaranteed to be only on one processor.
+            labelList findCells(const pointField&) const;
+
+            static void orientOutside(PtrList<searchableSurface>&);
+
+            //- Read feature edges
+            label readFeatureEdges();
+
+        // Snapping
+
+             //- Split surfaces into non-zoned and zones ones
+            void getZonedSurfaces(labelList&, labelList&) const;
+
+            //- Get faces to repatch. Returns map from face to patch.
+            Map<label> getZoneBafflePatches(const bool allowBoundary) const;
+
+            //- Calculates (geometric) shared points
+            static label getCollocatedPoints
+            (
+                const scalar tol,
+                const pointField&,
+                PackedList<1>&
+            );
+
+            //- Calculate displacement per patch point to smooth out patch.
+            //  Quite complicated in determining which points to move where.
+            pointField smoothPatchDisplacement(const motionSmoother&) const;
+
+            //- Check that face zones are synced
+            void checkCoupledFaceZones() const;
+
+            //- Per edge distance to patch
+            static tmp<scalarField> edgePatchDist
+            (
+                const pointMesh&,
+                const indirectPrimitivePatch&
+            );
+
+            //- Write displacement as .obj file.
+            static void dumpMove
+            (
+                const fileName&,
+                const pointField&,
+                const pointField&
+            );
+
+            //- Check displacement is outwards pointing
+            static bool outwardsDisplacement
+            (
+                const indirectPrimitivePatch&,
+                const vectorField&
+            );
+
+        // Face merging
+
+            //- Merge patch faces. Undo until no checkMesh errors.
+            label mergePatchFacesUndo
+            (
+                const scalar minCos,
+                const scalar concaveCos,
+                const dictionary&
+            );
+
+            //- Remove points.
+            autoPtr<mapPolyMesh> doRemovePoints
+            (
+                removePoints& pointRemover,
+                const boolList& pointCanBeDeleted
+            );
+
+            //- Restore faces (which contain removed points)
+            autoPtr<mapPolyMesh> doRestorePoints
+            (
+                removePoints& pointRemover,
+                const labelList& facesToRestore
+            );
+
+            //- Return candidateFaces that are also in set.
+            labelList collectFaces
+            (
+                const labelList& candidateFaces,
+                const labelHashSet& set
+            ) const;
+
+            //- Pick up faces of cells of faces in set.
+            labelList growFaceCellFace(const labelHashSet&) const;
+
+            //- Remove points not used by any face or points used by only
+            //  two faces where the edges are in line
+            label mergeEdgesUndo(const scalar minCos, const dictionary&);
+
+
+        // Layers
+
+            //- For debugging: Dump displacement to .obj files
+            static void dumpDisplacement
+            (
+                const fileName&,
+                const indirectPrimitivePatch&,
+                const vectorField&,
+                const List<extrudeMode>&
+            );
+
+            //- Check that primitivePatch is not multiply connected.
+            //  Collect non-manifold points in pointSet.
+            static void checkManifold
+            (
+                const indirectPrimitivePatch&,
+                pointSet& nonManifoldPoints
+            );
+
+
+            // Static extrusion setup
+
+                //- Unset extrusion on point. Returns true if anything unset.
+                static bool unmarkExtrusion
+                (
+                    const label patchPointI,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                );
+
+                //- Unset extrusion on face. Returns true if anything unset.
+                static bool unmarkExtrusion
+                (
+                    const face& localFace,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                );
+
+                //- No extrusion at non-manifold points.
+                void handleNonManifolds
+                (
+                    const indirectPrimitivePatch& pp,
+                    const labelList& meshEdges,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- No extrusion on feature edges. Assumes non-manifold
+                //  edges already handled.
+                void handleFeatureAngle
+                (
+                    const indirectPrimitivePatch& pp,
+                    const labelList& meshEdges,
+                    const scalar minCos,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- No extrusion on warped faces
+                void handleWarpedFaces
+                (
+                    const indirectPrimitivePatch& pp,
+                    const scalar faceRatio,
+                    const scalar edge0Len,
+                    const labelList& cellLevel,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- Determine the number of layers per point from the number of
+                //  layers per surface.
+                void setNumLayers
+                (
+                    const labelList& nLayers,
+                    const labelList& patchIDs,
+                    const indirectPrimitivePatch& pp,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- Grow no-extrusion layer.
+                static void growNoExtrusion
+                (
+                    const indirectPrimitivePatch& pp,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                );
+
+                //- Calculate pointwise wanted and minimum thickness.
+                //  thickness: wanted thickness
+                //  minthickness: when to give up and not extrude
+                void calculateLayerThickness
+                (
+                    const scalar expansionRatio,
+                    const scalar finalLayerRatio,
+                    const scalar relMinThickness,
+                    const indirectPrimitivePatch& pp,
+                    const labelList& cellLevel,
+                    const labelList& patchNLayers,
+                    const scalar edge0Len,
+                    scalarField& thickness,
+                    scalarField& minThickness
+                ) const;
+
+
+            // Extrusion execution
+
+                //- Synchronize displacement among coupled patches.
+                void syncPatchDisplacement
+                (
+                    const motionSmoother& meshMover,
+                    const scalarField& minThickness,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- Get nearest point on surface to snap to
+                void getPatchDisplacement
+                (
+                    const motionSmoother& meshMover,
+                    const scalarField& thickness,
+                    const scalarField& minThickness,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- Truncates displacement
+                // - for all patchFaces in the faceset displacement gets set
+                //   to zero
+                // - all displacement < minThickness gets set to zero
+                label truncateDisplacement
+                (
+                    const motionSmoother& meshMover,
+                    const scalarField& minThickness,
+                    const faceSet& illegalPatchFaces,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                ) const;
+
+                //- Setup layer information (at points and faces) to
+                //  modify mesh topology in
+                //  regions where layer mesh terminates. Guarantees an
+                //  optional slow decreasing of the number of layers.
+                //  Returns the number of layers per face and per point
+                //  to go into the actual layer addition engine.
+                void setupLayerInfoTruncation
+                (
+                    const motionSmoother& meshMover,
+                    const labelList& patchNLayers,
+                    const List<extrudeMode>& extrudeStatus,
+                    const label nBufferCellsNoExtrude,
+                    labelList& nPatchPointLayers,
+                    labelList& nPatchFaceLayers
+                ) const;
+
+                //- Does any of the cells use a face from faces?
+                static bool cellsUseFace
+                (
+                    const polyMesh& mesh,
+                    const labelList& cellLabels,
+                    const labelHashSet& faces
+                );
+
+                //- Checks the newly added cells and locally unmarks points
+                //  so they will not get extruded next time round. Returns
+                //  global number of unmarked points (0 if all was fine)
+                static label checkAndUnmark
+                (
+                    const addPatchCellLayer& addLayer,
+                    const dictionary& motionDict,
+                    const indirectPrimitivePatch& pp,
+                    const fvMesh&,
+
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    List<extrudeMode>& extrudeStatus
+                );
+
+                //- Count global number of extruded faces
+                static label countExtrusion
+                (
+                    const indirectPrimitivePatch& pp,
+                    const List<extrudeMode>& extrudeStatus
+                );
+
+                //- Collect layer faces and layer cells into bools
+                //  for ease of handling
+                static void getLayerCellsFaces
+                (
+                    const polyMesh&,
+                    const addPatchCellLayer&,
+                    boolList&,
+                    boolList&
+                );
+
+            // Mesh shrinking (to create space for layers)
+
+                //- Average field (over all subset of mesh points) by
+                //  summing contribution from edges. Global parallel since only
+                //  does master edges for coupled edges.
+                template<class Type>
+                void averageNeighbours
+                (
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const labelList& meshPoints,
+                    const edgeList& edges,
+                    const scalarField& invSumWeight,
+                    const Field<Type>& data,
+                    Field<Type>& average
+                ) const;
+
+                //- Calculate inverse sum of edge weights (currently always 1.0)
+                void sumWeights
+                (
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const labelList& meshPoints,
+                    const edgeList& edges,
+                    scalarField& invSumWeight
+                ) const;
+
+                //- Smooth scalar field on patch
+                void smoothField
+                (
+                    const motionSmoother& meshMover,
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const scalarField& fieldMin,
+                    const label& nSmoothDisp,
+                    scalarField& field
+                ) const;
+
+                //- Smooth normals on patch.
+                void smoothPatchNormals
+                (
+                    const motionSmoother& meshMover,
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const label nSmoothDisp,
+                    pointField& normals
+                ) const;
+
+                //- Smooth normals in interior.
+                void smoothNormals
+                (
+                    const label nSmoothDisp,
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& fixedPoints,
+                    pointVectorField& normals
+                ) const;
+
+                bool isMaxEdge
+                (
+                    const List<pointData>&,
+                    const label edgeI,
+                    const scalar minCos
+                ) const;
+
+                //- Stop layer growth where mesh wraps around edge with a
+                //  large feature angle
+                void handleFeatureAngleLayerTerminations
+                (
+                    const indirectPrimitivePatch& pp,
+                    const scalar minCos,
+                    List<extrudeMode>& extrudeStatus,
+                    pointField& patchDisp,
+                    labelList& patchNLayers,
+                    label& nPointCounter
+                ) const;
+
+                //- Find isolated islands (points, edges and faces and
+                // layer terminations)
+                // in the layer mesh and stop any layer growth at these points.
+                void findIsolatedRegions
+                (
+                    const indirectPrimitivePatch& pp,
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const scalar minCosLayerTermination,
+                    scalarField& field,
+                    List<extrudeMode>& extrudeStatus,
+                    pointField& patchDisp,
+                    labelList& patchNLayers
+                ) const;
+
+                // Calculate medial axis fields
+                void medialAxisSmoothingInfo
+                (
+                    const motionSmoother& meshMover,
+                    const label nSmoothNormals,
+                    const label nSmoothSurfaceNormals,
+                    const scalar minMedianAxisAngleCos,
+
+                    pointVectorField& dispVec,
+                    pointScalarField& medialRatio,
+                    pointScalarField& medialDist
+                ) const;
+
+                //- Main routine to shrink mesh
+                void shrinkMeshMedialDistance
+                (
+                    motionSmoother& meshMover,
+                    const label nSmoothThickness,
+                    const scalar maxThicknessToMedialRatio,
+                    const label nAllowableErrors,
+                    const label nSnap,
+                    const scalar minCosLayerTermination,
+
+                    const scalarField& layerThickness,
+                    const scalarField& minThickness,
+
+                    const pointVectorField& dispVec,
+                    const pointScalarField& medialRatio,
+                    const pointScalarField& medialDist,
+
+                    List<extrudeMode>& extrudeStatus,
+                    pointField& patchDisp,
+                    labelList& patchNLayers
+                ) const;
+
+
+        //- Disallow default bitwise copy construct
+        autoHexMeshDriver(const autoHexMeshDriver&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const autoHexMeshDriver&);
+
+public:
+
+    //- Runtime type information
+    ClassName("autoHexMeshDriver");
+
+
+    // Constructors
+
+        //- Construct from dictionary and mesh to modify
+        autoHexMeshDriver
+        (
+            fvMesh& mesh,
+            const dictionary& meshDict,
+            const dictionary& decomposeDict
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //- reference to mesh
+            const fvMesh& mesh() const
+            {
+                return mesh_;
+            }
+            fvMesh& mesh()
+            {
+                return mesh_;
+            }
+
+            //- Surfaces to base refinement on
+            const refinementSurfaces& surfaces() const
+            {
+                return surfacesPtr_();
+            }
+
+            //- Per refinementsurface, per region the patch
+            const labelList& globalToPatch() const
+            {
+                return globalToPatch_;
+            }
+
+
+        // Refinement
+
+            //- Refine around explicit feature edges
+            label featureEdgeRefine
+            (
+                const label maxIter,
+                const label minRefine
+            );
+
+            //- Refine at surface intersections
+            label surfaceOnlyRefine(const label maxIter);
+
+            //- Remove cells not reachable from keep points
+            void removeInsideCells(const label nBufferLayers);
+
+            //- Refine volume regions (interior of shells)
+            label shellRefine(const label maxIter);
+
+            //- Introduce baffles; remove unreachable mesh parts
+            //  handleSnapProblems : whether to remove free floating cells
+            void baffleAndSplitMesh(const bool handleSnapProblems);
+
+            //- Move cells to zones
+            void zonify();
+
+            //- Split and recombine baffles to get rid of single face baffles.
+            void splitAndMergeBaffles(const bool handleSnapProblems);
+
+            //- Merge multiple boundary faces on single cell
+            void mergePatchFaces();
+
+            //- Redecompose according to cell count
+            //  keepZoneFaces : find all faceZones from zoned surfaces and keep
+            //                  owner and neighbour together
+            //  keepBaffles   : find all baffles and keep them together
+            autoPtr<mapDistributePolyMesh> balance
+            (
+                const bool keepZoneFaces,
+                const bool keepBaffles
+            );
+
+            //- Write mesh
+            void writeMesh(const string&) const;
+
+
+        // Snapping
+
+            //- Create baffles for faces straddling zoned surfaces. Return
+            //  baffles.
+            autoPtr<mapPolyMesh> createZoneBaffles(List<labelPair>&);
+
+            //- Merge baffles.
+            autoPtr<mapPolyMesh> mergeZoneBaffles(const List<labelPair>&);
+
+            //- Calculate edge length per patch point.
+            scalarField calcSnapDistance(const indirectPrimitivePatch&) const;
+
+            //- Get patches generated for surfaces.
+            labelList getSurfacePatches() const;
+
+            //- Smooth the mesh (patch and internal) to increase visibility
+            //  of surface points (on castellated mesh) w.r.t. surface.
+            void preSmoothPatch
+            (
+                const label nInitErrors,
+                const List<labelPair>& baffles,
+                motionSmoother&
+            ) const;
+
+            //- Per patch point calculate point on nearest surface. Set as
+            //  boundary conditions of motionSmoother displacement field. Return
+            //  displacement of patch points.
+            vectorField calcNearestSurface
+            (
+                const scalarField& snapDist,
+                motionSmoother& meshMover
+            ) const;
+
+            //- Smooth the displacement field to the internal.
+            void smoothDisplacement(motionSmoother&) const;
+
+            //- Do the hard work: move the mesh according to displacement,
+            //  locally relax the displacement.
+            void scaleMesh
+            (
+                const label nInitErrors,
+                const List<labelPair>& baffles,
+                motionSmoother&
+            );
+
+
+        // Layers
+
+            //- Merge patch faces on same cell.
+            void mergePatchFacesUndo();
+
+            //- Read layer per region
+            labelList readNumLayers() const;
+
+            //- Check that mesh outside is not multiply connected.
+            void checkMeshManifold() const;
+
+            //- Add cell layers
+            void addLayers(const scalar nAllowableErrors, motionSmoother&);
+
+
+        // Other
+
+            //- Do all : refine, snap, layers
+            void doMesh();
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "autoHexMeshDriverTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
new file mode 100644
index 0000000000..a21b589ba3
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
@@ -0,0 +1,2999 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+    All to do with adding cell layers
+
+\*----------------------------------------------------------------------------*/
+
+#include "ListOps.H"
+#include "autoHexMeshDriver.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "combineFaces.H"
+#include "removePoints.H"
+#include "pointFields.H"
+#include "motionSmoother.H"
+#include "mathematicalConstants.H"
+#include "pointSet.H"
+#include "faceSet.H"
+#include "cellSet.H"
+#include "polyTopoChange.H"
+#include "mapPolyMesh.H"
+#include "addPatchCellLayer.H"
+#include "mapDistributePolyMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const Foam::scalar Foam::autoHexMeshDriver::defaultConcaveAngle = 90;
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::autoHexMeshDriver::mergePatchFacesUndo
+(
+    const scalar minCos,
+    const scalar concaveCos,
+    const dictionary& motionDict
+)
+{
+    // Patch face merging engine
+    combineFaces faceCombiner(mesh_, true);
+
+    // Get all sets of faces that can be merged
+    labelListList allFaceSets(faceCombiner.getMergeSets(minCos, concaveCos));
+
+    label nFaceSets = returnReduce(allFaceSets.size(), sumOp<label>());
+
+    Info<< "Merging " << nFaceSets << " sets of faces." << nl << endl;
+
+    if (nFaceSets > 0)
+    {
+        if (debug_)
+        {
+            faceSet allSets(mesh_, "allFaceSets", allFaceSets.size());
+            forAll(allFaceSets, setI)
+            {
+                forAll(allFaceSets[setI], i)
+                {
+                    allSets.insert(allFaceSets[setI][i]);
+                }
+            }
+            Pout<< "Writing all faces to be merged to set "
+                << allSets.objectPath() << endl;
+            allSets.write();
+        }
+
+
+        // Topology changes container
+        polyTopoChange meshMod(mesh_);
+
+        // Merge all faces of a set into the first face of the set.
+        faceCombiner.setRefinement(allFaceSets, meshMod);
+
+        // Experimental: store data for all the points that have been deleted
+        meshRefinerPtr_().storeData
+        (
+            faceCombiner.savedPointLabels(),    // points to store
+            labelList(0),                       // faces to store
+            labelList(0)                        // cells to store
+        );
+
+        // Change the mesh (no inflation)
+        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+
+        faceCombiner.updateMesh(map);
+
+        meshRefinerPtr_().updateMesh(map, labelList(0));
+
+
+
+        for (label iteration = 0; iteration < 100; iteration++)
+        {
+            Info<< nl
+                << "Undo iteration " << iteration << nl
+                << "----------------" << endl;
+
+
+            // Check mesh for errors
+            // ~~~~~~~~~~~~~~~~~~~~~
+
+            faceSet errorFaces
+            (
+                mesh_,
+                "errorFaces",
+                mesh_.nFaces()-mesh_.nInternalFaces()
+            );
+            bool hasErrors = motionSmoother::checkMesh
+            (
+                false,  // report
+                mesh_,
+                motionDict,
+                errorFaces
+            );
+            //if (checkEdgeConnectivity)
+            //{
+            //    Info<< "Checking edge-face connectivity (duplicate faces"
+            //        << " or non-consecutive shared vertices)" << endl;
+            //
+            //    label nOldSize = errorFaces.size();
+            //
+            //    hasErrors =
+            //        mesh_.checkFaceFaces
+            //        (
+            //            false,
+            //            &errorFaces
+            //        )
+            //     || hasErrors;
+            //
+            //    Info<< "Detected additional "
+            //        << returnReduce(errorFaces.size()-nOldSize, sumOp<label>())
+            //        << " faces with illegal face-face connectivity"
+            //        << endl;
+            //}
+
+            if (!hasErrors)
+            {
+                break;
+            }
+
+
+            if (debug_)
+            {
+                Pout<< "Writing all faces in error to faceSet "
+                    << errorFaces.objectPath() << nl << endl;
+                errorFaces.write();
+            }
+
+
+            // Check any master cells for using any of the error faces
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+            DynamicList<label> mastersToRestore(allFaceSets.size());
+
+            forAll(allFaceSets, setI)
+            {
+                label masterFaceI = faceCombiner.masterFace()[setI];
+
+                if (masterFaceI != -1)
+                {
+                    label masterCellII = mesh_.faceOwner()[masterFaceI];
+
+                    const cell& cFaces = mesh_.cells()[masterCellII];
+
+                    forAll(cFaces, i)
+                    {
+                        if (errorFaces.found(cFaces[i]))
+                        {
+                            mastersToRestore.append(masterFaceI);
+                            break;
+                        }
+                    }
+                }
+            }
+            mastersToRestore.shrink();
+
+            label nRestore = returnReduce
+            (
+                mastersToRestore.size(),
+                sumOp<label>()
+            );
+
+            Info<< "Masters that need to be restored:"
+                << nRestore << endl;
+
+            if (debug_)
+            {
+                faceSet restoreSet(mesh_, "mastersToRestore", mastersToRestore);
+                Pout<< "Writing all " << mastersToRestore.size()
+                    << " masterfaces to be restored to set "
+                    << restoreSet.objectPath() << endl;
+                restoreSet.write();
+            }
+
+
+            if (nRestore == 0)
+            {
+                break;
+            }
+
+
+            // Undo
+            // ~~~~
+
+            // Topology changes container
+            polyTopoChange meshMod(mesh_);
+
+            // Merge all faces of a set into the first face of the set.
+            // Experimental:mark all points/faces/cells that have been restored.
+            Map<label> restoredPoints(0);
+            Map<label> restoredFaces(0);
+            Map<label> restoredCells(0);
+
+            faceCombiner.setUnrefinement
+            (
+                mastersToRestore,
+                meshMod,
+                restoredPoints,
+                restoredFaces,
+                restoredCells
+            );
+
+            // Change the mesh (no inflation)
+            autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+            // Update fields
+            mesh_.updateMesh(map);
+
+            // Move mesh (since morphing does not do this)
+            if (map().hasMotionPoints())
+            {
+                mesh_.movePoints(map().preMotionPoints());
+            }
+
+            faceCombiner.updateMesh(map);
+
+            // Renumber restore maps
+            inplaceMapKey(map().reversePointMap(), restoredPoints);
+            inplaceMapKey(map().reverseFaceMap(), restoredFaces);
+            inplaceMapKey(map().reverseCellMap(), restoredCells);
+
+            // Experimental:restore all points/face/cells in maps
+            meshRefinerPtr_().updateMesh
+            (
+                map,
+                labelList(0),       // changedFaces
+                restoredPoints,
+                restoredFaces,
+                restoredCells
+            );
+
+            Info<< endl;
+        }
+
+        if (debug_)
+        {
+            Pout<< "**Writing merged-faces mesh to time "
+                << mesh_.time().timeName() << nl << endl;
+            mesh_.write();
+        }
+    }
+    else
+    {
+        Info<< "No faces merged ..." << endl;
+    }
+
+    return nFaceSets;
+}
+
+
+// Remove points. pointCanBeDeleted is parallel synchronised.
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::doRemovePoints
+(
+    removePoints& pointRemover,
+    const boolList& pointCanBeDeleted
+)
+{
+    // Topology changes container
+    polyTopoChange meshMod(mesh_);
+
+    pointRemover.setRefinement(pointCanBeDeleted, meshMod);
+
+    // Change the mesh (no inflation)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh (since morphing does not do this)
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+
+    pointRemover.updateMesh(map);
+    meshRefinerPtr_().updateMesh(map, labelList(0));
+
+    return map;
+}
+
+
+// Restore faces (which contain removed points)
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::doRestorePoints
+(
+    removePoints& pointRemover,
+    const labelList& facesToRestore
+)
+{
+    // Topology changes container
+    polyTopoChange meshMod(mesh_);
+
+    // Determine sets of points and faces to restore
+    labelList localFaces, localPoints;
+    pointRemover.getUnrefimentSet
+    (
+        facesToRestore,
+        localFaces,
+        localPoints
+    );
+
+    // Undo the changes on the faces that are in error.
+    pointRemover.setUnrefinement
+    (
+        localFaces,
+        localPoints,
+        meshMod
+    );
+
+    // Change the mesh (no inflation)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh (since morphing does not do this)
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+
+    pointRemover.updateMesh(map);
+    meshRefinerPtr_().updateMesh(map, labelList(0));
+
+    return map;
+}
+
+
+// Collect all faces that are both in candidateFaces and in the set.
+// If coupled face also collects the coupled face.
+Foam::labelList Foam::autoHexMeshDriver::collectFaces
+(
+    const labelList& candidateFaces,
+    const labelHashSet& set
+) const
+{
+    // Has face been selected?
+    boolList selected(mesh_.nFaces(), false);
+
+    forAll(candidateFaces, i)
+    {
+        label faceI = candidateFaces[i];
+
+        if (set.found(faceI))
+        {
+            selected[faceI] = true;
+        }
+    }
+    syncTools::syncFaceList
+    (
+        mesh_,
+        selected,
+        orEqOp<bool>(),     // combine operator
+        false               // separation
+    );
+
+    labelList selectedFaces(findIndices(selected, true));
+
+    return selectedFaces;
+}
+
+
+// Pick up faces of cells of faces in set.
+Foam::labelList Foam::autoHexMeshDriver::growFaceCellFace
+(
+    const labelHashSet& set
+) const
+{
+    boolList selected(mesh_.nFaces(), false);
+
+    forAllConstIter(faceSet, set, iter)
+    {
+        label faceI = iter.key();
+
+        label own = mesh_.faceOwner()[faceI];
+
+        const cell& ownFaces = mesh_.cells()[own];
+        forAll(ownFaces, ownFaceI)
+        {
+            selected[ownFaces[ownFaceI]] = true;
+        }
+
+        if (mesh_.isInternalFace(faceI))
+        {
+            label nbr = mesh_.faceNeighbour()[faceI];
+
+            const cell& nbrFaces = mesh_.cells()[nbr];
+            forAll(nbrFaces, nbrFaceI)
+            {
+                selected[nbrFaces[nbrFaceI]] = true;
+            }
+        }
+    }
+    syncTools::syncFaceList
+    (
+        mesh_,
+        selected,
+        orEqOp<bool>(),     // combine operator
+        false               // separation
+    );
+    return findIndices(selected, true);
+}
+
+
+// Remove points not used by any face or points used by only two faces where
+// the edges are in line
+Foam::label Foam::autoHexMeshDriver::mergeEdgesUndo
+(
+    const scalar minCos,
+    const dictionary& motionDict
+)
+{
+    Info<< nl
+        << "Merging all points on surface that" << nl
+        << "- are used by only two boundary faces and" << nl
+        << "- make an angle with a cosine of more than " << minCos
+        << "." << nl << endl;
+
+    // Point removal analysis engine with undo
+    removePoints pointRemover(mesh_, true);
+
+    // Count usage of points
+    boolList pointCanBeDeleted;
+    label nRemove = pointRemover.countPointUsage(minCos, pointCanBeDeleted);
+
+    if (nRemove > 0)
+    {
+        Info<< "Removing " << nRemove
+            << " straight edge points ..." << nl << endl;
+
+        // Remove points
+        // ~~~~~~~~~~~~~
+
+        doRemovePoints(pointRemover, pointCanBeDeleted);
+
+
+        for (label iteration = 0; iteration < 100; iteration++)
+        {
+            Info<< nl
+                << "Undo iteration " << iteration << nl
+                << "----------------" << endl;
+
+
+            // Check mesh for errors
+            // ~~~~~~~~~~~~~~~~~~~~~
+
+            faceSet errorFaces
+            (
+                mesh_,
+                "errorFaces",
+                mesh_.nFaces()-mesh_.nInternalFaces()
+            );
+            bool hasErrors = motionSmoother::checkMesh
+            (
+                false,  // report
+                mesh_,
+                motionDict,
+                errorFaces
+            );
+            //if (checkEdgeConnectivity)
+            //{
+            //    Info<< "Checking edge-face connectivity (duplicate faces"
+            //        << " or non-consecutive shared vertices)" << endl;
+            //
+            //    label nOldSize = errorFaces.size();
+            //
+            //    hasErrors =
+            //        mesh_.checkFaceFaces
+            //        (
+            //            false,
+            //            &errorFaces
+            //        )
+            //     || hasErrors;
+            //
+            //    Info<< "Detected additional "
+            //        << returnReduce(errorFaces.size()-nOldSize, sumOp<label>())
+            //        << " faces with illegal face-face connectivity"
+            //        << endl;
+            //}
+
+            if (!hasErrors)
+            {
+                break;
+            }
+
+            if (debug_)
+            {
+                Pout<< "**Writing all faces in error to faceSet "
+                    << errorFaces.objectPath() << nl << endl;
+                errorFaces.write();
+            }
+
+            labelList masterErrorFaces
+            (
+                collectFaces
+                (
+                    pointRemover.savedFaceLabels(),
+                    errorFaces
+                )
+            );
+
+            label n = returnReduce(masterErrorFaces.size(), sumOp<label>());
+
+            Info<< "Detected " << n
+                << " error faces on boundaries that have been merged."
+                << " These will be restored to their original faces." << nl
+                << endl;
+
+            if (n == 0)
+            {
+                if (hasErrors)
+                {
+                    Info<< "Detected "
+                        << returnReduce(errorFaces.size(), sumOp<label>())
+                        << " error faces in mesh."
+                        << " Restoring neighbours of faces in error." << nl
+                        << endl;
+
+                    labelList expandedErrorFaces
+                    (
+                        growFaceCellFace
+                        (
+                            errorFaces
+                        )
+                    );
+
+                    doRestorePoints(pointRemover, expandedErrorFaces);
+                }
+
+                break;
+            }
+
+            doRestorePoints(pointRemover, masterErrorFaces);
+        }
+
+        if (debug_)
+        {
+            Pout<< "**Writing merged-edges mesh to time "
+                << mesh_.time().timeName() << nl << endl;
+            mesh_.write();
+        }
+    }
+    else
+    {
+        Info<< "No straight edges simplified and no points removed ..." << endl;
+    }
+
+    return nRemove;
+}
+
+
+// For debugging: Dump displacement to .obj files
+void Foam::autoHexMeshDriver::dumpDisplacement
+(
+    const fileName& prefix,
+    const indirectPrimitivePatch& pp,
+    const vectorField& patchDisp,
+    const List<extrudeMode>& extrudeStatus
+)
+{
+    OFstream dispStr(prefix + "_disp.obj");
+    Info<< "Writing all displacements to " << dispStr.name() << nl << endl;
+
+    label vertI = 0;
+
+    forAll(patchDisp, patchPointI)
+    {
+        const point& pt = pp.localPoints()[patchPointI];
+
+        meshTools::writeOBJ(dispStr, pt); vertI++;
+        meshTools::writeOBJ(dispStr, pt + patchDisp[patchPointI]); vertI++;
+
+        dispStr << "l " << vertI-1 << ' ' << vertI << nl;
+    }
+
+
+    OFstream illStr(prefix + "_illegal.obj");
+    Info<< "Writing invalid displacements to " << illStr.name() << nl << endl;
+
+    vertI = 0;
+
+    forAll(patchDisp, patchPointI)
+    {
+        if (extrudeStatus[patchPointI] != EXTRUDE)
+        {
+            const point& pt = pp.localPoints()[patchPointI];
+
+            meshTools::writeOBJ(illStr, pt); vertI++;
+            meshTools::writeOBJ(illStr, pt + patchDisp[patchPointI]); vertI++;
+
+            illStr << "l " << vertI-1 << ' ' << vertI << nl;
+        }
+    }
+}
+
+
+// Check that primitivePatch is not multiply connected. Collect non-manifold
+// points in pointSet.
+void Foam::autoHexMeshDriver::checkManifold
+(
+    const indirectPrimitivePatch& fp,
+    pointSet& nonManifoldPoints
+)
+{
+    // Check for non-manifold points (surface pinched at point)
+    fp.checkPointManifold(false, &nonManifoldPoints);
+
+    // Check for edge-faces (surface pinched at edge)
+    const labelListList& edgeFaces = fp.edgeFaces();
+
+    forAll(edgeFaces, edgeI)
+    {
+        const labelList& eFaces = edgeFaces[edgeI];
+
+        if (eFaces.size() > 2)
+        {
+            const edge& e = fp.edges()[edgeI];
+
+            nonManifoldPoints.insert(fp.meshPoints()[e[0]]);
+            nonManifoldPoints.insert(fp.meshPoints()[e[1]]);
+        }
+    }
+}
+
+
+void Foam::autoHexMeshDriver::checkMeshManifold() const
+{
+    Info<< nl << "Checking mesh manifoldness ..." << endl;
+
+    // Get all outside faces
+    labelList outsideFaces(mesh_.nFaces() - mesh_.nInternalFaces());
+
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+         outsideFaces[faceI - mesh_.nInternalFaces()] = faceI;
+    }
+
+    pointSet nonManifoldPoints
+    (
+        mesh_,
+        "nonManifoldPoints",
+        mesh_.nPoints() / 100
+    );
+
+    // Build primitivePatch out of faces and check it for problems.
+    checkManifold
+    (
+        indirectPrimitivePatch
+        (
+            IndirectList<face>(mesh_.faces(), outsideFaces),
+            mesh_.points()
+        ),
+        nonManifoldPoints
+    );
+
+    label nNonManif = returnReduce(nonManifoldPoints.size(), sumOp<label>());
+
+    if (nNonManif > 0)
+    {
+        Info<< "Outside of mesh is multiply connected across edges or"
+            << " points." << nl
+            << "This is not a fatal error but might cause some unexpected"
+            << " behaviour." << nl
+            << "Writing " << nNonManif
+            << " points where this happens to pointSet "
+            << nonManifoldPoints.name() << endl;
+
+        nonManifoldPoints.write();
+    }
+    Info<< endl;
+}
+
+
+
+// Unset extrusion on point. Returns true if anything unset.
+bool Foam::autoHexMeshDriver::unmarkExtrusion
+(
+    const label patchPointI,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+)
+{
+    if (extrudeStatus[patchPointI] == EXTRUDE)
+    {
+        extrudeStatus[patchPointI] = NOEXTRUDE;
+        patchNLayers[patchPointI] = 0;
+        patchDisp[patchPointI] = vector::zero;
+        return true;
+    }
+    else if (extrudeStatus[patchPointI] == EXTRUDEREMOVE)
+    {
+        extrudeStatus[patchPointI] = NOEXTRUDE;
+        patchNLayers[patchPointI] = 0;
+        patchDisp[patchPointI] = vector::zero;
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Unset extrusion on face. Returns true if anything unset.
+bool Foam::autoHexMeshDriver::unmarkExtrusion
+(
+    const face& localFace,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+)
+{
+    bool unextruded = false;
+
+    forAll(localFace, fp)
+    {
+        if
+        (
+            unmarkExtrusion
+            (
+                localFace[fp],
+                patchDisp,
+                patchNLayers,
+                extrudeStatus
+            )
+        )
+        {
+            unextruded = true;
+        }
+    }
+    return unextruded;
+}
+
+
+// No extrusion at non-manifold points.
+void Foam::autoHexMeshDriver::handleNonManifolds
+(
+    const indirectPrimitivePatch& pp,
+    const labelList& meshEdges,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    Info<< nl << "Handling non-manifold points ..." << endl;
+
+    // Detect non-manifold points
+    Info<< nl << "Checking patch manifoldness ..." << endl;
+
+    pointSet nonManifoldPoints(mesh_, "nonManifoldPoints", pp.nPoints());
+
+    // 1. Local check
+    checkManifold(pp, nonManifoldPoints);
+
+    label nNonManif = returnReduce(nonManifoldPoints.size(), sumOp<label>());
+
+    Info<< "Outside of local patch is multiply connected across edges or"
+        << " points at " << nNonManif << " points." << endl;
+
+
+    const labelList& meshPoints = pp.meshPoints();
+
+
+    // 2. Parallel check
+    // For now disable extrusion at any shared edges.
+    const labelHashSet sharedEdgeSet(mesh_.globalData().sharedEdgeLabels());
+
+    forAll(pp.edges(), edgeI)
+    {
+        if (sharedEdgeSet.found(meshEdges[edgeI]))
+        {
+            const edge& e = mesh_.edges()[meshEdges[edgeI]];
+
+            Pout<< "Disabling extrusion at edge "
+                << mesh_.points()[e[0]] << mesh_.points()[e[1]]
+                << " since it is non-manifold across coupled patches."
+                << endl;
+
+            nonManifoldPoints.insert(e[0]);
+            nonManifoldPoints.insert(e[1]);
+        }
+    }
+
+    // 3b. extrusion can produce multiple faces between 2 cells
+    // across processor boundary
+    // This occurs when a coupled face shares more than 1 edge with a
+    // non-coupled boundary face.
+    // This is now correctly handled by addPatchCellLayer in that it
+    // extrudes a single face from the stringed up edges.
+
+
+    nNonManif = returnReduce(nonManifoldPoints.size(), sumOp<label>());
+
+    if (nNonManif > 0)
+    {
+        Info<< "Outside of patches is multiply connected across edges or"
+            << " points at " << nNonManif << " points." << nl
+            << "Writing " << nNonManif
+            << " points where this happens to pointSet "
+            << nonManifoldPoints.name() << nl
+            << "and setting layer thickness to zero on these points."
+            << endl;
+
+        nonManifoldPoints.write();
+
+        forAll(meshPoints, patchPointI)
+        {
+            if (nonManifoldPoints.found(meshPoints[patchPointI]))
+            {
+                unmarkExtrusion
+                (
+                    patchPointI,
+                    patchDisp,
+                    patchNLayers,
+                    extrudeStatus
+                );
+            }
+        }
+    }
+
+    Info<< "Set displacement to zero for all " << nNonManif
+        << " non-manifold points" << endl;
+}
+
+
+// Parallel feature edge detection. Assumes non-manifold edges already handled.
+void Foam::autoHexMeshDriver::handleFeatureAngle
+(
+    const indirectPrimitivePatch& pp,
+    const labelList& meshEdges,
+    const scalar minCos,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    Info<< nl << "Handling feature edges ..." << endl;
+
+    if (minCos < 1-SMALL)
+    {
+        // Normal component of normals of connected faces.
+        vectorField edgeNormal(mesh_.nEdges(), wallPoint::greatPoint);
+
+        const labelListList& edgeFaces = pp.edgeFaces();
+
+        forAll(edgeFaces, edgeI)
+        {
+            const labelList& eFaces = pp.edgeFaces()[edgeI];
+
+            label meshEdgeI = meshEdges[edgeI];
+
+            forAll(eFaces, i)
+            {
+                nomalsCombine()
+                (
+                    edgeNormal[meshEdgeI],
+                    pp.faceNormals()[eFaces[i]]
+                );
+            }
+        }
+
+        syncTools::syncEdgeList
+        (
+            mesh_,
+            edgeNormal,
+            nomalsCombine(),
+            wallPoint::greatPoint,  // null value
+            false                   // no separation
+        );
+
+        label vertI = 0;
+        autoPtr<OFstream> str;
+        if (debug_)
+        {
+            str.reset(new OFstream(mesh_.time().path()/"featureEdges.obj"));
+            Info<< "Writing feature edges to " << str().name() << endl;
+        }
+
+        label nFeats = 0;
+
+        // Now on coupled edges the edgeNormal will have been truncated and
+        // only be still be the old value where two faces have the same normal
+        forAll(edgeFaces, edgeI)
+        {
+            const labelList& eFaces = pp.edgeFaces()[edgeI];
+
+            label meshEdgeI = meshEdges[edgeI];
+
+            const vector& n = edgeNormal[meshEdgeI];
+
+            if (n != wallPoint::greatPoint)
+            {
+                scalar cos = n & pp.faceNormals()[eFaces[0]];
+
+                if (cos < minCos)
+                {
+                    const edge& e = pp.edges()[edgeI];
+
+                    unmarkExtrusion
+                    (
+                        e[0],
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    );
+                    unmarkExtrusion
+                    (
+                        e[1],
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    );
+
+                    nFeats++;
+
+                    if (str.valid())
+                    {
+                        meshTools::writeOBJ(str(), pp.localPoints()[e[0]]);
+                        vertI++;
+                        meshTools::writeOBJ(str(), pp.localPoints()[e[1]]);
+                        vertI++;
+                        str()<< "l " << vertI-1 << ' ' << vertI << nl;
+                    }
+                }
+            }
+        }
+
+        Info<< "Set displacement to zero for points on "
+            << returnReduce(nFeats, sumOp<label>())
+            << " feature edges" << endl;
+    }
+}
+
+
+// No extrusion on cells with warped faces. Calculates the thickness of the
+// layer and compares it to the space the warped face takes up. Disables
+// extrusion if layer thickness is more than faceRatio of the thickness of
+// the face.
+void Foam::autoHexMeshDriver::handleWarpedFaces
+(
+    const indirectPrimitivePatch& pp,
+    const scalar faceRatio,
+    const scalar edge0Len,
+    const labelList& cellLevel,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    Info<< nl << "Handling cells with warped patch faces ..." << nl;
+
+    const pointField& points = mesh_.points();
+
+    label nWarpedFaces = 0;
+
+    forAll(pp, i)
+    {
+        const face& f = pp[i];
+
+        if (f.size() > 3)
+        {
+            label faceI = pp.addressing()[i];
+
+            label ownLevel = cellLevel[mesh_.faceOwner()[faceI]];
+            scalar edgeLen = edge0Len/(1<<ownLevel);
+
+            // Normal distance to face centre plane
+            const point& fc = mesh_.faceCentres()[faceI];
+            const vector& fn = pp.faceNormals()[i];
+
+            scalarField vProj(f.size());
+
+            forAll(f, fp)
+            {
+                vector n = points[f[fp]] - fc;
+                vProj[fp] = (n & fn);
+            }
+
+            // Get normal 'span' of face
+            scalar minVal = min(vProj);
+            scalar maxVal = max(vProj);
+
+            if ((maxVal - minVal) > faceRatio * edgeLen)
+            {
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        pp.localFaces()[i],
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                    nWarpedFaces++;
+                }
+            }
+        }
+    }
+
+    Info<< "Set displacement to zero on "
+        << returnReduce(nWarpedFaces, sumOp<label>())
+        << " warped faces since layer would be > " << faceRatio
+        << " of the size of the bounding box." << endl;
+}
+
+
+
+//// No extrusion on cells with multiple patch faces. There ususally is a reason
+//// why combinePatchFaces hasn't succeeded.
+//void Foam::autoHexMeshDriver::handleMultiplePatchFaces
+//(
+//    const indirectPrimitivePatch& pp,
+//    pointField& patchDisp,
+//    labelList& patchNLayers,
+//    List<extrudeMode>& extrudeStatus
+//) const
+//{
+//    Info<< nl << "Handling cells with multiple patch faces ..." << nl;
+//
+//    const labelListList& pointFaces = pp.pointFaces();
+//
+//    // Cells that should not get an extrusion layer
+//    cellSet multiPatchCells(mesh_, "multiPatchCells", pp.size());
+//
+//    // Detect points that use multiple faces on same cell.
+//    forAll(pointFaces, patchPointI)
+//    {
+//        const labelList& pFaces = pointFaces[patchPointI];
+//
+//        labelHashSet pointCells(pFaces.size());
+//
+//        forAll(pFaces, i)
+//        {
+//            label cellI = mesh_.faceOwner()[pp.addressing()[pFaces[i]]];
+//
+//            if (!pointCells.insert(cellI))
+//            {
+//                // Second or more occurrence of cell so cell has two or more
+//                // pp faces connected to this point.
+//                multiPatchCells.insert(cellI);
+//            }
+//        }
+//    }
+//
+//    label nMultiPatchCells = returnReduce
+//    (
+//        multiPatchCells.size(),
+//        sumOp<label>()
+//    );
+//
+//    Info<< "Detected " << nMultiPatchCells
+//        << " cells with multiple (connected) patch faces." << endl;
+//
+//    label nChanged = 0;
+//
+//    if (nMultiPatchCells > 0)
+//    {
+//        Info<< "Writing " << nMultiPatchCells
+//            << " cells with multiple (connected) patch faces to cellSet "
+//            << multiPatchCells.objectPath() << endl;
+//        multiPatchCells.write();
+//
+//
+//        // Go through all points and remove extrusion on any cell in
+//        // multiPatchCells
+//        // (has to be done in separate loop since having one point on
+//        // multipatches has to reset extrusion on all points of cell)
+//
+//        forAll(pointFaces, patchPointI)
+//        {
+//            if (extrudeStatus[patchPointI] != NOEXTRUDE)
+//            {
+//                const labelList& pFaces = pointFaces[patchPointI];
+//
+//                forAll(pFaces, i)
+//                {
+//                    label cellI =
+//                        mesh_.faceOwner()[pp.addressing()[pFaces[i]]];
+//
+//                    if (multiPatchCells.found(cellI))
+//                    {
+//                        if
+//                        (
+//                            unmarkExtrusion
+//                            (
+//                                patchPointI,
+//                                patchDisp,
+//                                patchNLayers,
+//                                extrudeStatus
+//                            )
+//                        )
+//                        {
+//                            nChanged++;
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        reduce(nChanged, sumOp<label>());
+//    }
+//
+//    Info<< "Prevented extrusion on " << nChanged
+//        << " points due to multiple patch faces." << nl << endl;
+//}
+
+
+Foam::labelList Foam::autoHexMeshDriver::readNumLayers() const
+{
+    // Read dictionary information
+    // (could already be extracted in refinementSurfaces?)
+
+    const PtrList<dictionary>& surfaceDicts = dict_.lookup("surfaces");
+
+    labelList globalSurfLayers(surfaceDicts.size());
+    List<HashTable<label> > regionSurfLayers(surfaceDicts.size());
+
+    forAll(surfaceDicts, surfI)
+    {
+        const dictionary& dict = surfaceDicts[surfI];
+
+        globalSurfLayers[surfI] = readLabel(dict.lookup("surfaceLayers"));
+
+        if (dict.found("regions"))
+        {
+            // Per-region layer information
+
+            PtrList<dictionary> regionDicts(dict.lookup("regions"));
+
+            forAll(regionDicts, dictI)
+            {
+                const dictionary& regionDict = regionDicts[dictI];
+
+                const word regionName(regionDict.lookup("name"));
+
+                label nLayers = readLabel(regionDict.lookup("surfaceLayers"));
+
+                Info<< "    region " << regionName << ':'<< nl
+                    << "        surface layers:" << nLayers << nl;
+
+                regionSurfLayers[surfI].insert(regionName, nLayers);
+            }
+        }
+    }
+
+
+    // Transfer per surface/region information into global region info
+
+    labelList nLayers(surfaces().minLevel().size(), 0);
+
+    forAll(surfaces(), surfI)
+    {
+        const geometricSurfacePatchList& regions = surfaces()[surfI].patches();
+
+        forAll(regions, regionI)
+        {
+            label global = surfaces().globalRegion(surfI, regionI);
+
+            // Initialise to surface-wise layers
+            nLayers[global] = globalSurfLayers[surfI];
+
+            // Override with region specific data if available
+            HashTable<label>::const_iterator iter =
+                regionSurfLayers[surfI].find(regions[regionI].name());
+
+            if (iter != regionSurfLayers[surfI].end())
+            {
+                nLayers[global] = iter();
+            }
+
+            // Check
+            if (nLayers[global] < 0)
+            {
+                FatalErrorIn
+                (
+                    "autoHexMeshDriver::readNumLayers()"
+                )   << "Illegal number of layers " << nLayers[global]
+                    << " for surface "
+                    << surfaces().names()[surfI]
+                    << " region " << regions[regionI].name() << endl
+                    << exit(FatalError);
+            }
+        }
+    }
+    return nLayers;
+}
+
+
+// No extrusion on faces with differing number of layers for points
+void Foam::autoHexMeshDriver::setNumLayers
+(
+    const labelList& nLayers,
+    const labelList& patchIDs,
+    const indirectPrimitivePatch& pp,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    Info<< nl << "Handling points with inconsistent layer specification ..."
+        << endl;
+
+    // Build map from patch to layers
+    Map<label> patchToNLayers(nLayers.size());
+    forAll(nLayers, region)
+    {
+        if (globalToPatch_[region] != -1)
+        {
+            patchToNLayers.insert(globalToPatch_[region], nLayers[region]);
+        }
+    }
+
+    // Get for every point (really only nessecary on patch external points)
+    // the max and min of any patch faces using it.
+    labelList maxLayers(patchNLayers.size(), labelMin);
+    labelList minLayers(patchNLayers.size(), labelMax);
+
+    forAll(patchIDs, i)
+    {
+        label patchI = patchIDs[i];
+
+        const labelList& meshPoints = mesh_.boundaryMesh()[patchI].meshPoints();
+
+        label wantedLayers = patchToNLayers[patchI];
+
+        forAll(meshPoints, patchPointI)
+        {
+            label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
+
+            maxLayers[ppPointI] = max(wantedLayers, maxLayers[ppPointI]);
+            minLayers[ppPointI] = min(wantedLayers, minLayers[ppPointI]);
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        maxLayers,
+        maxEqOp<label>(),
+        labelMin,           // null value
+        false               // no separation
+    );
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        minLayers,
+        minEqOp<label>(),
+        labelMax,           // null value
+        false               // no separation
+    );
+
+    // Unmark any point with different min and max
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    label nConflicts = 0;
+
+    forAll(maxLayers, i)
+    {
+        if (maxLayers[i] == labelMin || minLayers[i] == labelMax)
+        {
+            FatalErrorIn("setNumLayers(..)")
+                << "Patchpoint:" << i << " coord:" << pp.localPoints()[i]
+                << " maxLayers:" << maxLayers
+                << " minLayers:" << minLayers
+                << abort(FatalError);
+        }
+        else if (maxLayers[i] == minLayers[i])
+        {
+            // Ok setting.
+            patchNLayers[i] = maxLayers[i];
+        }
+        else
+        {
+            // Inconsistent num layers between patch faces using point
+            //if
+            //(
+            //    unmarkExtrusion
+            //    (
+            //        i,
+            //        patchDisp,
+            //        patchNLayers,
+            //        extrudeStatus
+            //    )
+            //)
+            //{
+            //    nConflicts++;
+            //}
+            patchNLayers[i] = maxLayers[i];
+        }
+    }
+
+    reduce(nConflicts, sumOp<label>());
+
+    Info<< "Set displacement to zero for " << nConflicts
+        << " points due to points being on multiple regions"
+        << " with inconsistent nLayers specification." << endl;
+}
+
+
+// Grow no-extrusion layer
+void Foam::autoHexMeshDriver::growNoExtrusion
+(
+    const indirectPrimitivePatch& pp,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+)
+{
+    Info<< nl << "Growing non-extrusion points by one layer ..." << endl;
+
+    List<extrudeMode> grownExtrudeStatus(extrudeStatus);
+
+    const faceList& localFaces = pp.localFaces();
+
+    label nGrown = 0;
+
+    forAll(localFaces, faceI)
+    {
+        const face& f = localFaces[faceI];
+
+        bool hasSqueeze = false;
+        forAll(f, fp)
+        {
+            if (extrudeStatus[f[fp]] == NOEXTRUDE)
+            {
+                hasSqueeze = true;
+                break;
+            }
+        }
+
+        if (hasSqueeze)
+        {
+            // Squeeze all points of face
+            forAll(f, fp)
+            {
+                if
+                (
+                    extrudeStatus[f[fp]] == NOEXTRUDE
+                 && grownExtrudeStatus[f[fp]] != NOEXTRUDE
+                )
+                {
+                    grownExtrudeStatus[f[fp]] = NOEXTRUDE;
+                    nGrown++;
+                }
+            }
+        }
+    }
+
+    extrudeStatus.transfer(grownExtrudeStatus);
+
+    forAll(extrudeStatus, patchPointI)
+    {
+        if (extrudeStatus[patchPointI] == NOEXTRUDE)
+        {
+            patchDisp[patchPointI] = vector::zero;
+            patchNLayers[patchPointI] = 0;
+        }
+    }
+
+    reduce(nGrown, sumOp<label>());
+
+    Info<< "Set displacement to zero for an additional " << nGrown
+        << " points." << endl;
+}
+
+
+
+// Calculate pointwise wanted and minimum thickness.
+// thickness: wanted thickness per point
+void Foam::autoHexMeshDriver::calculateLayerThickness
+(
+    const scalar expansionRatio,
+    const scalar finalLayerRatio,
+    const scalar relMinThickness,
+    const indirectPrimitivePatch& pp,
+    const labelList& cellLevel,
+    const labelList& patchNLayers,
+    const scalar edge0Len,
+    scalarField& thickness,
+    scalarField& minThickness
+) const
+{
+    if (relMinThickness < 0 || relMinThickness > 2)
+    {
+        FatalErrorIn("calculateLayerThickness(..)")
+            << "Thickness should be factor of local undistorted cell size."
+            << " Valid values are [0..2]." << nl
+            << " minThickness:" << relMinThickness
+            << exit(FatalError);
+    }
+
+    thickness.setSize(pp.nPoints());
+    minThickness.setSize(pp.nPoints());
+
+    // Per point the max cell level of connected cells
+    labelList maxPointLevel(pp.nPoints(), labelMin);
+
+    forAll(pp, i)
+    {
+        label ownLevel = cellLevel[mesh_.faceOwner()[pp.addressing()[i]]];
+
+        const face& f = pp.localFaces()[i];
+
+        forAll(f, fp)
+        {
+            maxPointLevel[f[fp]] = max(maxPointLevel[f[fp]], ownLevel);
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        maxPointLevel,
+        maxEqOp<label>(),
+        labelMin,           // null value
+        false               // no separation
+    );
+
+
+    forAll(maxPointLevel, pointI)
+    {
+        // Find undistorted edge size for this level.
+        scalar edgeLen = edge0Len/(1<<maxPointLevel[pointI]);
+
+        // Calculate layer thickness based on expansion ratio
+        // and final layer height
+        if (expansionRatio == 1)
+        {
+            thickness[pointI] = finalLayerRatio*patchNLayers[pointI]*edgeLen;
+            minThickness[pointI] = relMinThickness*edgeLen;
+        }
+        else
+        {
+            scalar invExpansion = 1.0 / expansionRatio;
+            label nLay = patchNLayers[pointI];
+            thickness[pointI] = finalLayerRatio*edgeLen
+                * (1.0 - pow(invExpansion, nLay))
+                / (1.0 - invExpansion);
+            minThickness[pointI] = relMinThickness*edgeLen;
+        }
+    }
+
+    Info<< "calculateLayerThickness : min:" << gMin(thickness)
+        << " max:" << gMax(thickness) << endl;
+}
+
+
+// Synchronize displacement among coupled patches.
+void Foam::autoHexMeshDriver::syncPatchDisplacement
+(
+    const motionSmoother& meshMover,
+    const scalarField& minThickness,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const labelList& meshPoints = meshMover.patch().meshPoints();
+
+    label nChangedTotal = 0;
+
+    while (true)
+    {
+        label nChanged = 0;
+
+        // Sync displacement (by taking min)
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            patchDisp,
+            minEqOp<vector>(),
+            wallPoint::greatPoint,          // null value
+            false                           // no separation
+        );
+
+        // Unmark if displacement too small
+        forAll(patchDisp, i)
+        {
+            if (mag(patchDisp[i]) < minThickness[i])
+            {
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        i,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                    nChanged++;
+                }
+            }
+        }
+
+        labelList syncPatchNLayers(patchNLayers);
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            syncPatchNLayers,
+            minEqOp<label>(),
+            labelMax,           // null value
+            false               // no separation
+        );
+
+        // Reset if differs
+        forAll(syncPatchNLayers, i)
+        {
+            if (syncPatchNLayers[i] != patchNLayers[i])
+            {
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        i,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                    nChanged++;
+                }
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            syncPatchNLayers,
+            maxEqOp<label>(),
+            labelMin,           // null value
+            false               // no separation
+        );
+
+        // Reset if differs
+        forAll(syncPatchNLayers, i)
+        {
+            if (syncPatchNLayers[i] != patchNLayers[i])
+            {
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        i,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                    nChanged++;
+                }
+            }
+        }
+        nChangedTotal += nChanged;
+
+        if (!returnReduce(nChanged, sumOp<label>()))
+        {
+            break;
+        }
+    }
+
+    Info<< "Prevented extrusion on "
+        << returnReduce(nChangedTotal, sumOp<label>())
+        << " coupled patch points during syncPatchDisplacement." << endl;
+}
+
+
+// Calculate displacement vector for all patch points. Uses pointNormal.
+// Checks that displaced patch point would be visible from all centres
+// of the faces using it.
+// extrudeStatus is both input and output and gives the status of each
+// patch point.
+void Foam::autoHexMeshDriver::getPatchDisplacement
+(
+    const motionSmoother& meshMover,
+    const scalarField& thickness,
+    const scalarField& minThickness,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    Info<< nl << "Determining displacement for added points"
+        << " according to pointNormal ..." << endl;
+
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const vectorField& faceNormals = pp.faceNormals();
+    const labelListList& pointFaces = pp.pointFaces();
+    const pointField& localPoints = pp.localPoints();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Determine pointNormal
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    pointField pointNormals(pp.nPoints(), vector::zero);
+    {
+        labelList nPointFaces(pp.nPoints(), 0);
+
+        forAll(faceNormals, faceI)
+        {
+            const face& f = pp.localFaces()[faceI];
+
+            forAll(f, fp)
+            {
+                pointNormals[f[fp]] += faceNormals[faceI];
+                nPointFaces[f[fp]] ++;
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            pointNormals,
+            plusEqOp<vector>(),
+            vector::zero,       // null value
+            false               // no separation
+        );
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            nPointFaces,
+            plusEqOp<label>(),
+            0,                  // null value
+            false               // no separation
+        );
+
+        forAll(pointNormals, i)
+        {
+            pointNormals[i] /= nPointFaces[i];
+        }
+    }
+
+
+    // Determine local length scale on patch
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Start off from same thickness everywhere (except where no extrusion)
+    patchDisp = thickness*pointNormals;
+
+    // Check if no extrude possible.
+    forAll(pointNormals, patchPointI)
+    {
+        label meshPointI = pp.meshPoints()[patchPointI];
+
+        if (extrudeStatus[patchPointI] == NOEXTRUDE)
+        {
+            // Do not use unmarkExtrusion; forcibly set to zero extrusion.
+            patchNLayers[patchPointI] = 0;
+            patchDisp[patchPointI] = vector::zero;
+        }
+        else
+        {
+            // Get normal
+            const vector& n = pointNormals[patchPointI];
+
+            if (!meshTools::visNormal(n, faceNormals, pointFaces[patchPointI]))
+            {
+                Pout<< "No valid normal for point " << meshPointI
+                    << ' ' << pp.points()[meshPointI]
+                    << "; setting displacement to " << patchDisp[patchPointI]
+                    << endl;
+
+                extrudeStatus[patchPointI] = EXTRUDEREMOVE;
+            }
+        }
+    }
+
+    // At illegal points make displacement average of new neighbour positions
+    forAll(extrudeStatus, patchPointI)
+    {
+        if (extrudeStatus[patchPointI] == EXTRUDEREMOVE)
+        {
+            point avg(vector::zero);
+            label nPoints = 0;
+
+            const labelList& pEdges = pp.pointEdges()[patchPointI];
+
+            forAll(pEdges, i)
+            {
+                label edgeI = pEdges[i];
+
+                label otherPointI = pp.edges()[edgeI].otherVertex(patchPointI);
+
+                if (extrudeStatus[otherPointI] != NOEXTRUDE)
+                {
+                    avg += localPoints[otherPointI] + patchDisp[otherPointI];
+                    nPoints++;
+                }
+            }
+
+            if (nPoints > 0)
+            {
+                Pout<< "Displacement at illegal point "
+                    << localPoints[patchPointI]
+                    << " set to " << (avg / nPoints - localPoints[patchPointI])
+                    << endl;
+
+                patchDisp[patchPointI] =
+                    avg / nPoints
+                  - localPoints[patchPointI];
+            }
+        }
+    }
+
+    // Make sure displacement is equal on both sides of coupled patches.
+    syncPatchDisplacement
+    (
+        meshMover,
+        minThickness,
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    Info<< endl;
+}
+
+
+// Truncates displacement
+// - for all patchFaces in the faceset displacement gets set to zero
+// - all displacement < minThickness gets set to zero
+Foam::label Foam::autoHexMeshDriver::truncateDisplacement
+(
+    const motionSmoother& meshMover,
+    const scalarField& minThickness,
+    const faceSet& illegalPatchFaces,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const polyMesh& mesh = meshMover.mesh();
+    const indirectPrimitivePatch& pp = meshMover.patch();
+
+    label nChanged = 0;
+
+    const Map<label>& meshPointMap = pp.meshPointMap();
+
+    forAllConstIter(faceSet, illegalPatchFaces, iter)
+    {
+        label faceI = iter.key();
+
+        if (mesh.isInternalFace(faceI))
+        {
+            FatalErrorIn("truncateDisplacement(..)")
+                << "Faceset " << illegalPatchFaces.name()
+                << " contains internal face " << faceI << nl
+                << "It should only contain patch faces" << abort(FatalError);
+        }
+
+        const face& f = mesh.faces()[faceI];
+
+
+        forAll(f, fp)
+        {
+            if (meshPointMap.found(f[fp]))
+            {
+                label patchPointI = meshPointMap[f[fp]];
+
+                if (extrudeStatus[patchPointI] != NOEXTRUDE)
+                {
+                    unmarkExtrusion
+                    (
+                        patchPointI,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    );
+                    nChanged++;
+                }
+            }
+        }
+    }
+
+    forAll(patchDisp, patchPointI)
+    {
+        if (mag(patchDisp[patchPointI]) < minThickness[patchPointI])
+        {
+            if
+            (
+                unmarkExtrusion
+                (
+                    patchPointI,
+                    patchDisp,
+                    patchNLayers,
+                    extrudeStatus
+                )
+            )
+            {
+                nChanged++;
+            }
+        }
+        else if (extrudeStatus[patchPointI] == NOEXTRUDE)
+        {
+            // Make sure displacement is 0. Should already be so but ...
+            patchDisp[patchPointI] = vector::zero;
+            patchNLayers[patchPointI] = 0;
+        }
+    }
+
+
+    const faceList& localFaces = pp.localFaces();
+
+    while (true)
+    {
+        syncPatchDisplacement
+        (
+            meshMover,
+            minThickness,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+
+        // Make sure that a face doesn't have two non-consecutive areas
+        // not extruded (e.g. quad where vertex 0 and 2 are not extruded
+        // but 1 and 3 are) since this gives topological errors.
+
+        label nPinched = 0;
+
+        forAll(localFaces, i)
+        {
+            const face& localF = localFaces[i];
+
+            // Count number of transitions from unsnapped to snapped.
+            label nTrans = 0;
+
+            extrudeMode prevMode = extrudeStatus[localF.prevLabel(0)];
+
+            forAll(localF, fp)
+            {
+                extrudeMode fpMode = extrudeStatus[localF[fp]];
+
+                if (prevMode == NOEXTRUDE && fpMode != NOEXTRUDE)
+                {
+                    nTrans++;
+                }
+                prevMode = fpMode;
+            }
+
+            if (nTrans > 1)
+            {
+                // Multiple pinches. Reset whole face as unextruded.
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        localF,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                    nPinched++;
+                    nChanged++;
+                }
+            }
+        }
+
+        reduce(nPinched, sumOp<label>());
+
+        Info<< "truncateDisplacement : Unextruded " << nPinched
+            << " faces due to non-consecutive vertices being extruded." << endl;
+
+
+        // Make sure that a face has consistent number of layers for all
+        // its vertices.
+
+        label nDiffering = 0;
+
+        //forAll(localFaces, i)
+        //{
+        //    const face& localF = localFaces[i];
+        //
+        //    label numLayers = -1;
+        //
+        //    forAll(localF, fp)
+        //    {
+        //        if (patchNLayers[localF[fp]] > 0)
+        //        {
+        //            if (numLayers == -1)
+        //            {
+        //                numLayers = patchNLayers[localF[fp]];
+        //            }
+        //            else if (numLayers != patchNLayers[localF[fp]])
+        //            {
+        //                // Differing number of layers
+        //                if
+        //                (
+        //                    unmarkExtrusion
+        //                    (
+        //                        localF,
+        //                        patchDisp,
+        //                        patchNLayers,
+        //                        extrudeStatus
+        //                    )
+        //                )
+        //                {
+        //                    nDiffering++;
+        //                    nChanged++;
+        //                }
+        //                break;
+        //            }
+        //        }
+        //    }
+        //}
+        //
+        //reduce(nDiffering, sumOp<label>());
+        //
+        //Info<< "truncateDisplacement : Unextruded " << nDiffering
+        //    << " faces due to having differing number of layers." << endl;
+
+        if (nPinched+nDiffering == 0)
+        {
+            break;
+        }
+    }
+
+    return nChanged;
+}
+
+
+// Setup layer information (at points and faces) to modify mesh topology in
+// regions where layer mesh terminates.
+void Foam::autoHexMeshDriver::setupLayerInfoTruncation
+(
+    const motionSmoother& meshMover,
+    const labelList& patchNLayers,
+    const List<extrudeMode>& extrudeStatus,
+    const label nBufferCellsNoExtrude,
+    labelList& nPatchPointLayers,
+    labelList& nPatchFaceLayers
+) const
+{
+    Info<< nl << "Setting up information for layer truncation ..." << endl;
+
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const polyMesh& mesh = meshMover.mesh();
+
+    if (nBufferCellsNoExtrude < 0)
+    {
+        Info<< nl << "Performing no layer truncation."
+            << " nBufferCellsNoExtrude set to less than 0  ..." << endl;
+
+        // Face layers if any point get extruded
+        forAll(pp.localFaces(), patchFaceI)
+        {
+            const face& f = pp.localFaces()[patchFaceI];
+
+            forAll(f, fp)
+            {
+                if (patchNLayers[f[fp]] > 0)
+                {
+                    nPatchFaceLayers[patchFaceI] = patchNLayers[f[fp]];
+                    break;
+                }
+            }
+        }
+        nPatchPointLayers = patchNLayers;
+    }
+    else
+    {
+        // Determine max point layers per face.
+        labelList maxLevel(pp.size(), 0);
+
+        forAll(pp.localFaces(), patchFaceI)
+        {
+            const face& f = pp.localFaces()[patchFaceI];
+
+            // find patch faces where layer terminates (i.e contains extrude
+            // and noextrude points).
+
+            bool noExtrude = false;
+            label mLevel = 0;
+
+            forAll(f, fp)
+            {
+                if (extrudeStatus[f[fp]] == NOEXTRUDE)
+                {
+                    noExtrude = true;
+                }
+                mLevel = max(mLevel, patchNLayers[f[fp]]);
+            }
+
+            if (mLevel > 0)
+            {
+                // So one of the points is extruded. Check if all are extruded
+                // or is a mix.
+
+                if (noExtrude)
+                {
+                    nPatchFaceLayers[patchFaceI] = 1;
+                    maxLevel[patchFaceI] = mLevel;
+                }
+                else
+                {
+                    maxLevel[patchFaceI] = mLevel;
+                }
+            }
+        }
+
+        // We have the seed faces (faces with nPatchFaceLayers != maxLevel)
+        // Now do a meshwave across the patch where we pick up neighbours
+        // of seed faces.
+        // Note: quite inefficient. Could probably be coded better.
+
+        const labelListList& pointFaces = pp.pointFaces();
+
+        label nLevels = gMax(patchNLayers);
+
+        // flag neighbouring patch faces with number of layers to grow
+        for (label ilevel = 1; ilevel < nLevels; ilevel++)
+        {
+            label nBuffer;
+
+            if (ilevel == 1)
+            {
+                nBuffer = nBufferCellsNoExtrude - 1;
+            }
+            else
+            {
+                nBuffer = nBufferCellsNoExtrude;
+            }
+
+            for (label ibuffer = 0; ibuffer < nBuffer + 1; ibuffer++)
+            {
+                labelList tempCounter(nPatchFaceLayers);
+
+                boolList foundNeighbour(pp.nPoints(), false);
+
+                forAll(pp.meshPoints(), patchPointI)
+                {
+                    forAll(pointFaces[patchPointI], pointFaceI)
+                    {
+                        label faceI = pointFaces[patchPointI][pointFaceI];
+
+                        if
+                        (
+                            nPatchFaceLayers[faceI] != -1
+                         && maxLevel[faceI] > 0
+                        )
+                        {
+                            foundNeighbour[patchPointI] = true;
+                            break;
+                        }
+                    }
+                }
+
+                syncTools::syncPointList
+                (
+                    mesh,
+                    pp.meshPoints(),
+                    foundNeighbour,
+                    orEqOp<bool>(),
+                    false,              // null value
+                    false               // no separation
+                );
+
+                forAll(pp.meshPoints(), patchPointI)
+                {
+                    if (foundNeighbour[patchPointI])
+                    {
+                        forAll(pointFaces[patchPointI], pointFaceI)
+                        {
+                            label faceI = pointFaces[patchPointI][pointFaceI];
+                            if
+                            (
+                                nPatchFaceLayers[faceI] == -1
+                             && maxLevel[faceI] > 0
+                             && ilevel < maxLevel[faceI]
+                            )
+                            {
+                                tempCounter[faceI] = ilevel;
+                            }
+                        }
+                    }
+                }
+                nPatchFaceLayers = tempCounter;
+            }
+        }
+
+        forAll(pp.localFaces(), patchFaceI)
+        {
+            if (nPatchFaceLayers[patchFaceI] == -1)
+            {
+                nPatchFaceLayers[patchFaceI] = maxLevel[patchFaceI];
+            }
+        }
+
+        forAll(pp.meshPoints(), patchPointI)
+        {
+            if (extrudeStatus[patchPointI] != NOEXTRUDE)
+            {
+                forAll(pointFaces[patchPointI], pointFaceI)
+                {
+                    label face = pointFaces[patchPointI][pointFaceI];
+                    nPatchPointLayers[patchPointI] = max
+                    (
+                        nPatchPointLayers[patchPointI],
+                        nPatchFaceLayers[face]
+                    );
+                }
+            }
+            else
+            {
+                nPatchPointLayers[patchPointI] = 0;
+            }
+        }
+        syncTools::syncPointList
+        (
+            mesh,
+            pp.meshPoints(),
+            nPatchPointLayers,
+            maxEqOp<label>(),
+            0,                  // null value
+            false               // no separation
+        );
+    }
+}
+
+
+// Does any of the cells use a face from faces?
+bool Foam::autoHexMeshDriver::cellsUseFace
+(
+    const polyMesh& mesh,
+    const labelList& cellLabels,
+    const labelHashSet& faces
+)
+{
+    forAll(cellLabels, i)
+    {
+        const cell& cFaces = mesh.cells()[cellLabels[i]];
+
+        forAll(cFaces, cFaceI)
+        {
+            if (faces.found(cFaces[cFaceI]))
+            {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+
+// Checks the newly added cells and locally unmarks points so they
+// will not get extruded next time round. Returns global number of unmarked
+// points (0 if all was fine)
+Foam::label Foam::autoHexMeshDriver::checkAndUnmark
+(
+    const addPatchCellLayer& addLayer,
+    const dictionary& motionDict,
+    const indirectPrimitivePatch& pp,
+    const fvMesh& newMesh,
+
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+)
+{
+    // Check the resulting mesh for errors
+    Info<< nl << "Checking mesh with layer ..." << endl;
+    faceSet wrongFaces(newMesh, "wrongFaces", newMesh.nFaces()/1000);
+    motionSmoother::checkMesh(false, newMesh, motionDict, wrongFaces);
+    Info<< "Detected " << returnReduce(wrongFaces.size(), sumOp<label>())
+        << " illegal faces"
+        << " (concave, zero area or negative cell pyramid volume)"
+        << endl;
+
+    // Undo local extrusion if
+    // - any of the added cells in error
+
+    label nChanged = 0;
+
+    // Get all cells in the layer.
+    labelListList addedCells
+    (
+        addPatchCellLayer::addedCells
+        (
+            newMesh,
+            addLayer.layerFaces()
+        )
+    );
+
+    // Check if any of the faces in error uses any face of an added cell
+    forAll(addedCells, oldPatchFaceI)
+    {
+        // Get the cells (in newMesh labels) per old patch face (in mesh
+        // labels)
+        const labelList& fCells = addedCells[oldPatchFaceI];
+
+        if (cellsUseFace(newMesh, fCells, wrongFaces))
+        {
+            // Unmark points on old mesh
+            if
+            (
+                unmarkExtrusion
+                (
+                    pp.localFaces()[oldPatchFaceI],
+                    patchDisp,
+                    patchNLayers,
+                    extrudeStatus
+                )
+            )
+            {
+                nChanged++;
+            }
+        }
+    }
+
+    return returnReduce(nChanged, sumOp<label>());
+}
+
+
+//- Count global number of extruded faces
+Foam::label Foam::autoHexMeshDriver::countExtrusion
+(
+    const indirectPrimitivePatch& pp,
+    const List<extrudeMode>& extrudeStatus
+)
+{
+    // Count number of extruded patch faces
+    label nExtruded = 0;
+    {
+        const faceList& localFaces = pp.localFaces();
+
+        forAll(localFaces, i)
+        {
+            const face& localFace = localFaces[i];
+
+            forAll(localFace, fp)
+            {
+                if (extrudeStatus[localFace[fp]] != NOEXTRUDE)
+                {
+                    nExtruded++;
+                    break;
+                }
+            }
+        }
+    }
+
+    return returnReduce(nExtruded, sumOp<label>());
+}
+
+
+// Collect layer faces and layer cells into bools for ease of handling
+void Foam::autoHexMeshDriver::getLayerCellsFaces
+(
+    const polyMesh& mesh,
+    const addPatchCellLayer& addLayer,
+    boolList& flaggedCells,
+    boolList& flaggedFaces
+)
+{
+    flaggedCells.setSize(mesh.nCells());
+    flaggedCells = false;
+    flaggedFaces.setSize(mesh.nFaces());
+    flaggedFaces = false;
+
+    // Mark all faces in the layer
+    const labelListList& layerFaces = addLayer.layerFaces();
+
+    // Mark all cells in the layer.
+    labelListList addedCells(addPatchCellLayer::addedCells(mesh, layerFaces));
+
+    forAll(addedCells, oldPatchFaceI)
+    {
+        const labelList& added = addedCells[oldPatchFaceI];
+
+        forAll(added, i)
+        {
+            flaggedCells[added[i]] = true;
+        }
+    }
+
+    forAll(layerFaces, oldPatchFaceI)
+    {
+        const labelList& layer = layerFaces[oldPatchFaceI];
+
+        if (layer.size() > 0)
+        {
+            for (label i = 1; i < layer.size()-1; i++)
+            {
+                flaggedFaces[layer[i]] = true;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::autoHexMeshDriver::mergePatchFacesUndo()
+{
+    const dictionary& shrinkDict = dict_.subDict("shrinkDict");
+
+    const scalar featureAngle(readScalar(shrinkDict.lookup("featureAngle")));
+    scalar minCos = Foam::cos(featureAngle*mathematicalConstant::pi/180.0);
+
+    scalar concaveAngle = defaultConcaveAngle;
+
+    if (shrinkDict.found("concaveAngle"))
+    {
+        concaveAngle = readScalar(shrinkDict.lookup("concaveAngle"));
+    }
+    scalar concaveCos = Foam::cos(concaveAngle*mathematicalConstant::pi/180.0);
+
+    Info<< nl
+        << "Merging all faces of a cell" << nl
+        << "---------------------------" << nl
+        << "    - which are on the same patch" << nl
+        << "    - which make an angle < " << featureAngle << " degrees"
+        << nl
+        << "      (cos:" << minCos << ')' << nl
+        << "    - as long as the resulting face doesn't become concave"
+        << " by more than "
+        << concaveAngle << " degrees (0=straight, 180=fully concave)" << nl
+        << endl;
+
+
+    const dictionary& motionDict = dict_.subDict("motionDict");
+
+    label nChanged = mergePatchFacesUndo(minCos, concaveCos, motionDict);
+
+    nChanged += mergeEdgesUndo(minCos, motionDict);
+}
+
+
+void Foam::autoHexMeshDriver::addLayers
+(
+    const scalar nAllowableErrors,
+    motionSmoother& meshMover
+)
+{
+    // Read some more dictionary settings
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const dictionary& shrinkDict = dict_.subDict("shrinkDict");
+
+    // Min thickness per cell
+    const scalar relMinThickness(readScalar(shrinkDict.lookup("minThickness")));
+
+    // Warped faces recoginition
+    const scalar maxFaceThicknessRatio
+    (
+        readScalar(shrinkDict.lookup("maxFaceThicknessRatio"))
+    );
+    const scalar featureAngle(readScalar(shrinkDict.lookup("featureAngle")));
+
+    // Feature angle
+    const scalar minCos = Foam::cos(featureAngle*mathematicalConstant::pi/180.);
+
+    // Number of layers for to grow non-extrusion region by
+    const label nGrow(readLabel(shrinkDict.lookup("nGrow")));
+
+    //const label nSmoothDisp(readLabel(shrinkDict.lookup("nSmoothDispl")));
+    // Snapping iterations
+    const label nSnap(readLabel(shrinkDict.lookup("nSnap")));
+
+    // Mesh termination and medial axis smoothing quantities
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const scalar minCosLayerTermination =
+        Foam::cos(0.5*featureAngle*mathematicalConstant::pi/180.);
+    const scalar expansionRatio
+    (
+        readScalar(shrinkDict.lookup("expansionRatio"))
+    );
+    const scalar finalLayerRatio
+    (
+        readScalar(shrinkDict.lookup("finalLayerRatio"))
+    );
+    const label nBufferCellsNoExtrude
+    (
+        readLabel(shrinkDict.lookup("nBufferCellsNoExtrude"))
+    );
+    const label nSmoothSurfaceNormals
+    (
+        readLabel(shrinkDict.lookup("nSmoothSurfaceNormals"))
+    );
+    const label nSmoothNormals(readLabel(shrinkDict.lookup("nSmoothNormals")));
+    const label nSmoothThickness
+    (
+        readLabel(shrinkDict.lookup("nSmoothThickness"))
+    );
+    const scalar maxThicknessToMedialRatio
+    (
+        readScalar(shrinkDict.lookup("maxThicknessToMedialRatio"))
+    );
+
+    // Medial axis setup
+
+    const scalar minMedianAxisAngle
+    (
+        readScalar(shrinkDict.lookup("minMedianAxisAngle"))
+    );
+    const scalar minMedianAxisAngleCos =
+        Foam::cos(minMedianAxisAngle*mathematicalConstant::pi/180.);
+
+
+    // Precalculate mesh edge labels for patch edges
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const labelList& meshPoints = pp.meshPoints();
+
+    labelList meshEdges(pp.nEdges());
+    forAll(pp.edges(), edgeI)
+    {
+        const edge& ppEdge = pp.edges()[edgeI];
+        label v0 = meshPoints[ppEdge[0]];
+        label v1 = meshPoints[ppEdge[1]];
+        meshEdges[edgeI] = meshTools::findEdge
+        (
+            mesh_.edges(),
+            mesh_.pointEdges()[v0],
+            v0,
+            v1
+        );
+    }
+
+    // Displacement for all pp.localPoints.
+    vectorField patchDisp(pp.nPoints(), vector::one);
+
+    // Number of layers for all pp.localPoints. Note: only valid if
+    // extrudeStatus = EXTRUDE.
+    labelList patchNLayers(pp.nPoints(), 0);
+
+    // Whether to add edge for all pp.localPoints.
+    List<extrudeMode> extrudeStatus(pp.nPoints(), EXTRUDE);
+
+
+    // Get number of layer per point from number of layers per patch
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    setNumLayers
+    (
+        readNumLayers(),
+        meshMover.adaptPatchIDs(),
+        pp,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on non-manifold points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    handleNonManifolds
+    (
+        pp,
+        meshEdges,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on feature angles
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    handleFeatureAngle
+    (
+        pp,
+        meshEdges,
+        minCos,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on warped faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Undistorted edge length
+    const scalar edge0Len = meshRefinerPtr_().meshCutter().level0EdgeLength();
+    const labelList& cellLevel = meshRefinerPtr_().meshCutter().cellLevel();
+
+    handleWarpedFaces
+    (
+        pp,
+        maxFaceThicknessRatio,
+        edge0Len,
+        cellLevel,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    //// Disable extrusion on cells with multiple patch faces
+    //// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //
+    //handleMultiplePatchFaces
+    //(
+    //    pp,
+    //
+    //    patchDisp,
+    //    patchNLayers,
+    //    extrudeStatus
+    //);
+
+
+    // Grow out region of non-extrusion
+    for (label i = 0; i < nGrow; i++)
+    {
+        growNoExtrusion
+        (
+            pp,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+    }
+
+    // Determine point-wise layer thickness
+    scalarField thickness(pp.nPoints());
+    scalarField minThickness(pp.nPoints());
+    calculateLayerThickness
+    (
+        expansionRatio,
+        finalLayerRatio,
+        relMinThickness,
+        pp,
+        cellLevel,
+        patchNLayers,
+        edge0Len,
+
+        thickness,
+        minThickness
+    );
+
+    // Calculate wall to medial axis distance for smoothing displacement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    pointScalarField pointMedialDist
+    (
+        IOobject
+        (
+            "pointMedialDist",
+            mesh_.time().timeName(),
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        meshMover.pMesh(),
+        dimensionedScalar("pointMedialDist", dimless, 0.0)
+    );
+
+    pointVectorField dispVec
+    (
+        IOobject
+        (
+            "dispVec",
+            mesh_.time().timeName(),
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        meshMover.pMesh(),
+        dimensionedVector("dispVec", dimless, vector::zero)
+    );
+
+    pointScalarField medialRatio
+    (
+        IOobject
+        (
+            "medialRatio",
+            mesh_.time().timeName(),
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        meshMover.pMesh(),
+        dimensionedScalar("medialRatio", dimless, 0.0)
+    );
+
+    // Setup information for medial axis smoothing. Calculates medial axis
+    // and a smoothed displacement direction.
+    // - pointMedialDist : distance to medial axis
+    // - dispVec : normalised direction of nearest displacement
+    // - medialRatio : ratio of medial distance to wall distance.
+    //   (1 at wall, 0 at medial axis)
+    medialAxisSmoothingInfo
+    (
+        meshMover,
+        nSmoothNormals,
+        nSmoothSurfaceNormals,
+        minMedianAxisAngleCos,
+
+        dispVec,
+        medialRatio,
+        pointMedialDist
+    );
+
+
+
+    // Saved old points
+    pointField oldPoints(mesh_.points());
+
+    // Last set of topology changes. (changing mesh clears out polyTopoChange)
+    polyTopoChange savedMeshMod(mesh_.boundaryMesh().size());
+
+    boolList flaggedCells;
+    boolList flaggedFaces;
+
+    while (true)
+    {
+        // Make sure displacement is equal on both sides of coupled patches.
+        syncPatchDisplacement
+        (
+            meshMover,
+            minThickness,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+
+        // Displacement acc. to pointnormals
+        getPatchDisplacement
+        (
+            meshMover,
+            thickness,
+            minThickness,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+
+        // Shrink mesh by displacement value first.
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        {
+            pointField oldPatchPos(pp.localPoints());
+
+            //// Laplacian displacement shrinking.
+            //shrinkMeshDistance
+            //(
+            //    debug,
+            //    meshMover,
+            //    -patchDisp,     // Shrink in opposite direction of addedPoints
+            //    nSmoothDisp,
+            //    nSnap
+            //);
+
+            // Medial axis based shrinking
+            shrinkMeshMedialDistance
+            (
+                meshMover,
+
+                nSmoothThickness,
+                maxThicknessToMedialRatio,
+                nAllowableErrors,
+                nSnap,
+                minCosLayerTermination,
+
+                thickness,
+                minThickness,
+
+                dispVec,
+                medialRatio,
+                pointMedialDist,
+
+                extrudeStatus,
+                patchDisp,
+                patchNLayers
+            );
+
+            // Update patchDisp (since not all might have been honoured)
+            patchDisp = oldPatchPos - pp.localPoints();
+        }
+
+        // Truncate displacements that are too small (this will do internal
+        // ones, coupled ones have already been truncated by syncPatch)
+        faceSet dummySet(mesh_, "wrongPatchFaces", 0);
+        truncateDisplacement
+        (
+            meshMover,
+            minThickness,
+            dummySet,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+
+
+        // Dump to .obj file for debugging.
+        if (debug_)
+        {
+            dumpDisplacement
+            (
+                mesh_.time().path()/"layer",
+                pp,
+                patchDisp,
+                extrudeStatus
+            );
+
+            const_cast<Time&>(mesh_.time())++;
+            Info<< "Writing shrunk mesh to " << mesh_.time().timeName() << endl;
+            mesh_.write();
+        }
+
+
+        // Mesh topo change engine
+        polyTopoChange meshMod(mesh_);
+
+        // Grow layer of cells on to patch. Handles zero sized displacement.
+        addPatchCellLayer addLayer(mesh_);
+
+        // Determine per point/per face number of layers to extrude. Also
+        // handles the slow termination of layers when going switching layers
+
+        labelList nPatchPointLayers(pp.nPoints(),-1);
+        labelList nPatchFaceLayers(pp.localFaces().size(),-1);
+        setupLayerInfoTruncation
+        (
+            meshMover,
+            patchNLayers,
+            extrudeStatus,
+            nBufferCellsNoExtrude,
+            nPatchPointLayers,
+            nPatchFaceLayers
+        );
+
+        // Calculate displacement for first layer for addPatchLayer
+        vectorField firstDisp(patchNLayers.size(), vector::zero);
+
+        forAll(patchNLayers, i)
+        {
+            if (patchNLayers[i] > 0)
+            {
+                if (expansionRatio == 1.0)
+                {
+                    firstDisp[i] = patchDisp[i]/nPatchPointLayers[i];
+                }
+                else
+                {
+                    label nLay = nPatchPointLayers[i];
+                    scalar h =
+                        pow(expansionRatio,nLay - 1)
+                      * (mag(patchDisp[i])*(1.0 - expansionRatio))
+                      / (1.0 - pow(expansionRatio, nLay));
+                    firstDisp[i] = h/mag(patchDisp[i])*patchDisp[i];
+                }
+            }
+        }
+
+        scalar invExpansionRatio = 1.0 / expansionRatio;
+
+        // Add topo regardless of whether extrudeStatus is extruderemove.
+        // Not add layer if patchDisp is zero.
+        addLayer.setRefinement
+        (
+            invExpansionRatio,
+            pp,
+            nPatchFaceLayers,   // layers per face
+            nPatchPointLayers,  // layers per point
+            firstDisp,          // thickness of first layer
+            meshMod
+        );
+
+        if (debug_)
+        {
+            const_cast<Time&>(mesh_.time())++;
+        }
+
+        // Store mesh changes for if mesh is correct.
+        savedMeshMod = meshMod;
+
+
+        // With the stored topo changes we create a new mesh so we can
+        // undo if neccesary.
+
+        autoPtr<fvMesh> newMeshPtr;
+        autoPtr<mapPolyMesh> map = meshMod.makeMesh
+        (
+            newMeshPtr,
+            IOobject
+            (
+                //mesh.name()+"_layer",
+                mesh_.name(),
+                static_cast<polyMesh&>(mesh_).instance(),
+                mesh_.db(),
+                static_cast<polyMesh&>(mesh_).readOpt(),
+                static_cast<polyMesh&>(mesh_).writeOpt()
+            ),          // io params from original mesh but new name
+            mesh_,      // original mesh
+            true        // parallel sync
+        );
+        fvMesh& newMesh = newMeshPtr();
+
+        //?neccesary? Update fields
+        newMesh.updateMesh(map);
+
+        // Update numbering on addLayer:
+        // - cell/point labels to be newMesh.
+        // - patchFaces to remain in oldMesh order.
+        addLayer.updateMesh
+        (
+            map,
+            identity(pp.size()),
+            identity(pp.nPoints())
+        );
+
+        // Collect layer faces and cells for outside loop.
+        getLayerCellsFaces
+        (
+            newMesh,
+            addLayer,
+            flaggedCells,
+            flaggedFaces
+        );
+
+
+        if (debug_)
+        {
+            Info<< "*** Writing layer mesh to "
+                << mesh_.time().timeName() << endl;
+            newMesh.write();
+            cellSet addedCellSet
+            (
+                newMesh,
+                "addedCells",
+                findIndices(flaggedCells, true)
+            );
+            Info<< "Writing "
+                << returnReduce(addedCellSet.size(), sumOp<label>())
+                << " added cells to cellSet "
+                << addedCellSet.objectPath()
+                << endl;
+            addedCellSet.write();
+
+            faceSet layerFacesSet
+            (
+                newMesh,
+                "layerFaces",
+                findIndices(flaggedCells, true)
+            );
+            Info<< "Writing "
+                << returnReduce(layerFacesSet.size(), sumOp<label>())
+                << " faces inside added layer to faceSet "
+                << layerFacesSet.objectPath()
+                << endl;
+            layerFacesSet.write();
+        }
+
+        // Unset the extrusion at the pp.
+        label nTotChanged = checkAndUnmark
+        (
+            addLayer,
+            dict_.subDict("motionDict"),
+            pp,
+            newMesh,
+
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+
+        Info<< "Extruding " << countExtrusion(pp, extrudeStatus)
+            << " out of " << returnReduce(pp.size(), sumOp<label>())
+            << " faces. Removed extrusion at " << nTotChanged << " faces."
+            << endl;
+
+        if (nTotChanged == 0)
+        {
+            break;
+        }
+
+        // Reset mesh points and start again
+        meshMover.movePoints(oldPoints);
+        meshMover.correct();
+    }
+
+
+    // At this point we have a (shrunk) mesh and a set of topology changes
+    // which will make a valid mesh with layer. Apply these changes to the
+    // current mesh.
+
+    // Apply the stored topo changes to the current mesh.
+    autoPtr<mapPolyMesh> map = savedMeshMod.changeMesh(mesh_, false);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh (since morphing does not do this)
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+
+    meshRefinerPtr_().updateMesh(map, labelList(0));
+
+
+    // Do final balancing
+    // ~~~~~~~~~~~~~~~~~~
+
+    if (Pstream::parRun())
+    {
+        // Balance. No restriction on face zones and baffles.
+        autoPtr<mapDistributePolyMesh> map = balance(false, false);
+
+        // Re-distribute flag of layer faces and cells
+        map().distributeCellData(flaggedCells);
+        map().distributeFaceData(flaggedFaces);
+    }
+
+
+    // Write mesh
+    // ~~~~~~~~~~
+
+    //writeMesh("Layer mesh");
+    cellSet addedCellSet(mesh_, "addedCells", findIndices(flaggedCells, true));
+    Info<< "Writing "
+        << returnReduce(addedCellSet.size(), sumOp<label>())
+        << " added cells to cellSet "
+        << addedCellSet.objectPath()
+        << endl;
+    addedCellSet.write();
+
+    faceSet layerFacesSet(mesh_, "layerFaces", findIndices(flaggedCells, true));
+    Info<< "Writing "
+        << returnReduce(layerFacesSet.size(), sumOp<label>())
+        << " faces inside added layer to faceSet "
+        << layerFacesSet.objectPath()
+        << endl;
+    layerFacesSet.write();
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C
new file mode 100644
index 0000000000..37e96eb88d
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C
@@ -0,0 +1,1151 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+    Shrinking mesh (part of adding cell layers)
+
+\*----------------------------------------------------------------------------*/
+
+#include "autoHexMeshDriver.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "pointFields.H"
+#include "motionSmoother.H"
+#include "pointData.H"
+#include "PointEdgeWave.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Calculate inverse sum of edge weights (currently always 1.0)
+void Foam::autoHexMeshDriver::sumWeights
+(
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const labelList& meshPoints,
+    const edgeList& edges,
+    scalarField& invSumWeight
+) const
+{
+    invSumWeight = 0;
+
+    forAll(edges, edgeI)
+    {
+        if (isMasterEdge.get(meshEdges[edgeI]) == 1)
+        {
+            const edge& e = edges[edgeI];
+            //scalar eWeight = edgeWeights[edgeI];
+            scalar eWeight = 1.0;
+
+            invSumWeight[e[0]] += eWeight;
+            invSumWeight[e[1]] += eWeight;
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        meshPoints,
+        invSumWeight,
+        plusEqOp<scalar>(),
+        scalar(0.0),        // null value
+        false               // no separation
+    );
+
+    forAll(invSumWeight, pointI)
+    {
+        scalar w = invSumWeight[pointI];
+
+        if (w > 0.0)
+        {
+            invSumWeight[pointI] = 1.0/w;
+        }
+    }
+}
+
+
+// Smooth field on moving patch
+void Foam::autoHexMeshDriver::smoothField
+(
+    const motionSmoother& meshMover,
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const scalarField& fieldMin,
+    const label& nSmoothDisp,
+    scalarField& field
+) const
+{
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const edgeList& edges = pp.edges();
+    const labelList& meshPoints = pp.meshPoints();
+
+    scalarField invSumWeight(pp.nPoints());
+    sumWeights
+    (
+        isMasterEdge,
+        meshEdges,
+        meshPoints,
+        edges,
+        invSumWeight
+    );
+
+    // Get smoothly varying patch field.
+    Info<< "shrinkMeshDistance : Smoothing field ..." << endl;
+
+    for (label iter = 0; iter < nSmoothDisp; iter++)
+    {
+        scalarField average(pp.nPoints());
+        averageNeighbours
+        (
+            isMasterEdge,
+            meshEdges,
+            meshPoints,
+            pp.edges(),
+            invSumWeight,
+            field,
+            average
+        );
+
+        // Transfer to field
+        forAll(field, pointI)
+        {
+            //full smoothing neighbours + point value
+            average[pointI] = 0.5*(field[pointI]+average[pointI]);
+
+            // perform monotonic smoothing
+            if
+            (
+                average[pointI] < field[pointI]
+             && average[pointI] >= fieldMin[pointI]
+            )
+            {
+                field[pointI] = average[pointI];
+            }
+        }
+
+        // Do residual calculation every so often.
+        if ((iter % 10) == 0)
+        {
+            Info<< "    Iteration " << iter << "   residual "
+                <<  gSum(mag(field-average))
+                   /returnReduce(average.size(), sumOp<label>())
+                << endl;
+        }
+    }
+}
+
+
+// Smooth normals on moving patch.
+void Foam::autoHexMeshDriver::smoothPatchNormals
+(
+    const motionSmoother& meshMover,
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const label nSmoothDisp,
+    pointField& normals
+) const
+{
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const edgeList& edges = pp.edges();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Calculate inverse sum of weights
+
+    scalarField invSumWeight(pp.nPoints());
+    sumWeights
+    (
+        isMasterEdge,
+        meshEdges,
+        meshPoints,
+        edges,
+        invSumWeight
+    );
+
+    // Get smoothly varying internal normals field.
+    Info<< "shrinkMeshDistance : Smoothing normals ..." << endl;
+
+    for (label iter = 0; iter < nSmoothDisp; iter++)
+    {
+        vectorField average(pp.nPoints());
+        averageNeighbours
+        (
+            isMasterEdge,
+            meshEdges,
+            meshPoints,
+            pp.edges(),
+            invSumWeight,
+            normals,
+            average
+        );
+
+        // Do residual calculation every so often.
+        if ((iter % 10) == 0)
+        {
+            Info<< "    Iteration " << iter << "   residual "
+                <<  gSum(mag(normals-average))
+                   /returnReduce(average.size(), sumOp<label>())
+                << endl;
+        }
+
+        // Transfer to normals vector field
+        forAll(average, pointI)
+        {
+            // full smoothing neighbours + point value
+            average[pointI] = 0.5*(normals[pointI]+average[pointI]);
+            normals[pointI] = average[pointI];
+            normals[pointI] /= mag(normals[pointI]) + VSMALL;
+        }
+    }
+}
+
+
+// Smooth normals in interior.
+void Foam::autoHexMeshDriver::smoothNormals
+(
+    const label nSmoothDisp,
+    const PackedList<1>& isMasterEdge,
+    const labelList& fixedPoints,
+    pointVectorField& normals
+) const
+{
+    // Get smoothly varying internal normals field.
+    Info<< "shrinkMeshDistance : Smoothing normals ..." << endl;
+
+    const edgeList& edges = mesh_.edges();
+
+    // Points that do not change.
+    PackedList<1> isFixedPoint(mesh_.nPoints(), 0);
+
+    // Internal points that are fixed
+    forAll(fixedPoints, i)
+    {
+        label meshPointI = fixedPoints[i];
+        isFixedPoint.set(meshPointI, 1);
+    }
+
+    // Correspondence between local edges/points and mesh edges/points
+    const labelList meshEdges(identity(mesh_.nEdges()));
+    const labelList meshPoints(identity(mesh_.nPoints()));
+
+    // Calculate inverse sum of weights
+
+    scalarField invSumWeight(mesh_.nPoints(), 0);
+    sumWeights
+    (
+        isMasterEdge,
+        meshEdges,
+        meshPoints,
+        edges,
+        invSumWeight
+    );
+
+    Info<< "shrinkMeshDistance : Smoothing normals in interior ..." << endl;
+
+    for (label iter = 0; iter < nSmoothDisp; iter++)
+    {
+        vectorField average(mesh_.nPoints());
+        averageNeighbours
+        (
+            isMasterEdge,
+            meshEdges,
+            meshPoints,
+            edges,
+            invSumWeight,
+            normals,
+            average
+        );
+
+        // Do residual calculation every so often.
+        if ((iter % 10) == 0)
+        {
+            Info<< "    Iteration " << iter << "   residual "
+                <<  gSum(mag(normals-average))
+                   /returnReduce(average.size(), sumOp<label>())
+                << endl;
+        }
+
+
+        // Transfer to normals vector field
+        forAll(average, pointI)
+        {
+            if (isFixedPoint.get(pointI) == 0)
+            {
+                //full smoothing neighbours + point value
+                average[pointI] = 0.5*(normals[pointI]+average[pointI]);
+                normals[pointI] = average[pointI];
+                normals[pointI] /= mag(normals[pointI]) + VSMALL;
+            }
+        }
+    }
+}
+
+
+// Tries and find a medial axis point. Done by comparing vectors to nearest
+// wall point for both vertices of edge.
+bool Foam::autoHexMeshDriver::isMaxEdge
+(
+    const List<pointData>& pointWallDist,
+    const label edgeI,
+    const scalar minCos
+) const
+{
+    const pointField& points = mesh_.points();
+
+    // Do not mark edges with one side on moving wall.
+
+    const edge& e = mesh_.edges()[edgeI];
+
+    vector v0(points[e[0]] - pointWallDist[e[0]].origin());
+    scalar magV0(mag(v0));
+
+    if (magV0 < SMALL)
+    {
+        return false;
+    }
+
+    vector v1(points[e[1]] - pointWallDist[e[1]].origin());
+    scalar magV1(mag(v1));
+
+    if (magV1 < SMALL)
+    {
+        return false;
+    }
+
+    v0 /= magV0;
+    v1 /= magV1;
+
+    // Test angle.
+    if ((v0 & v1) < minCos)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Stop layer growth where mesh wraps around edge with a
+// large feature angle
+void Foam::autoHexMeshDriver::handleFeatureAngleLayerTerminations
+(
+    const indirectPrimitivePatch& pp,
+    const scalar minCos,
+    List<extrudeMode>& extrudeStatus,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    label& nPointCounter
+) const
+{
+    // Mark faces that have all points extruded
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    boolList extrudedFaces(pp.size(), true);
+
+    forAll(pp.localFaces(), faceI)
+    {
+        const face& f = pp.localFaces()[faceI];
+
+        forAll(f, fp)
+        {
+            if (extrudeStatus[f[fp]] == NOEXTRUDE)
+            {
+                extrudedFaces[faceI] = false;
+                break;
+            }
+        }
+    }
+
+
+    // Detect situation where two featureedge-neighbouring faces are partly or
+    // not extruded and the edge itself is extruded. In this case unmark the
+    // edge for extrusion.
+
+    forAll(pp.edgeFaces(), edgeI)
+    {
+        const labelList& eFaces = pp.edgeFaces()[edgeI];
+
+        if (eFaces.size() == 2)
+        {
+            const edge& e = pp.edges()[edgeI];
+            label v0 = e[0];
+            label v1 = e[1];
+
+            if
+            (
+                extrudeStatus[v0] != NOEXTRUDE
+             || extrudeStatus[v1] != NOEXTRUDE
+            )
+            {
+                if (!extrudedFaces[eFaces[0]] || !extrudedFaces[eFaces[1]])
+                {
+                    const vector& n0 = pp.faceNormals()[eFaces[0]];
+                    const vector& n1 = pp.faceNormals()[eFaces[1]];
+
+                    if ((n0 & n1) < minCos)
+                    {
+                        if
+                        (
+                            unmarkExtrusion
+                            (
+                                v0,
+                                patchDisp,
+                                patchNLayers,
+                                extrudeStatus
+                            )
+                        )
+                        {
+                            nPointCounter++;
+                        }
+                        if
+                        (
+                            unmarkExtrusion
+                            (
+                                v1,
+                                patchDisp,
+                                patchNLayers,
+                                extrudeStatus
+                            )
+                        )
+                        {
+                            nPointCounter++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+// Find isolated islands (points, edges and faces and layer terminations)
+// in the layer mesh and stop any layer growth at these points.
+void Foam::autoHexMeshDriver::findIsolatedRegions
+(
+    const indirectPrimitivePatch& pp,
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const scalar minCosLayerTermination,
+    scalarField& field,
+    List<extrudeMode>& extrudeStatus,
+    pointField& patchDisp,
+    labelList& patchNLayers
+) const
+{
+    Info<< "shrinkMeshDistance : Removing isolated regions ..." << endl;
+
+    // Keep count of number of points unextruded
+    label nPointCounter = 0;
+
+    while(true)
+    {
+        // Stop layer growth where mesh wraps around edge with a
+        // large feature angle
+        handleFeatureAngleLayerTerminations
+        (
+            pp,
+            minCosLayerTermination,
+
+            extrudeStatus,
+            patchDisp,
+            patchNLayers,
+            nPointCounter
+        );
+
+
+        // Do not extrude from point where all neighbouring
+        // faces are not grown
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        boolList extrudedFaces(pp.size(), true);
+        forAll(pp.localFaces(), faceI)
+        {
+            const face& f = pp.localFaces()[faceI];
+            forAll(f, fp)
+            {
+                if (extrudeStatus[f[fp]] == NOEXTRUDE)
+                {
+                    extrudedFaces[faceI] = false;
+                    break;
+                }
+            }
+        }
+
+        const labelListList& pointFaces = pp.pointFaces();
+
+        boolList keptPoints(pp.nPoints(), false);
+        forAll(keptPoints, patchPointI)
+        {
+            const labelList& pFaces = pointFaces[patchPointI];
+
+            forAll(pFaces, i)
+            {
+                label faceI = pFaces[i];
+                if (extrudedFaces[faceI])
+                {
+                    keptPoints[patchPointI] = true;
+                    break;
+                }
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            pp.meshPoints(),
+            keptPoints,
+            orEqOp<bool>(),
+            false,              // null value
+            false               // no separation
+        );
+
+        label nChanged = 0;
+
+        forAll(keptPoints, patchPointI)
+        {
+            if (!keptPoints[patchPointI])
+            {
+                if
+                (
+                    unmarkExtrusion
+                    (
+                        patchPointI,
+                        patchDisp,
+                        patchNLayers,
+                        extrudeStatus
+                    )
+                )
+                {
+                   nPointCounter++;
+                   nChanged++;
+                }
+           }
+       }
+
+
+       if (returnReduce(nChanged, sumOp<label>()) == 0)
+       {
+           break;
+       }
+   }
+
+    const edgeList& edges = pp.edges();
+
+
+    // Count number of mesh edges using a point
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList isolatedPoint(pp.nPoints(),0);
+
+    forAll(edges, edgeI)
+    {
+        if (isMasterEdge.get(meshEdges[edgeI]) == 1)
+        {
+            const edge& e = edges[edgeI];
+
+            label v0 = e[0];
+            label v1 = e[1];
+
+            if (extrudeStatus[v1] != NOEXTRUDE)
+            {
+                isolatedPoint[v0] += 1;
+            }
+            if (extrudeStatus[v0] != NOEXTRUDE)
+            {
+                isolatedPoint[v1] += 1;
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        isolatedPoint,
+        plusEqOp<label>(),
+        0,       // null value
+        false    // no separation
+    );
+
+    // stop layer growth on isolated faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    forAll(pp, faceI)
+    {
+        const face& f = pp.localFaces()[faceI];
+        bool failed = false;
+        forAll(f, fp)
+        {
+            if (isolatedPoint[f[fp]] > 2)
+            {
+                failed = true;
+                break;
+            }
+        }
+        bool allPointsExtruded = true;
+        if (!failed)
+        {
+            forAll(f, fp)
+            {
+                if (extrudeStatus[f[fp]] == NOEXTRUDE)
+                {
+                    allPointsExtruded = false;
+                    break;
+                }
+            }
+
+            if (allPointsExtruded)
+            {
+                forAll(f, fp)
+                {
+                    if
+                    (
+                        unmarkExtrusion
+                        (
+                            f[fp],
+                            patchDisp,
+                            patchNLayers,
+                            extrudeStatus
+                        )
+                    )
+                    {
+                        field[f[fp]] = 0.0;
+                        nPointCounter++;
+                    }
+                }
+            }
+        }
+    }
+
+    reduce(nPointCounter, sumOp<label>());
+    Info<< "Number isolated points extrusion stopped : "<< nPointCounter<< endl;
+}
+
+
+// Calculates medial axis fields:
+// dispVec     : normal of nearest wall. Where this normal changes direction
+//               defines the medial axis
+// medialDist  : distance to medial axis
+// medialRatio : ratio of medial distance to wall distance.
+//               (1 at wall, 0 at medial axis)
+void Foam::autoHexMeshDriver::medialAxisSmoothingInfo
+(
+    const motionSmoother& meshMover,
+    const label nSmoothNormals,
+    const label nSmoothSurfaceNormals,
+    const scalar minMedianAxisAngleCos,
+
+    pointVectorField& dispVec,
+    pointScalarField& medialRatio,
+    pointScalarField& medialDist
+) const
+{
+
+    Info<< "medialAxisSmoothingInfo :"
+        << " Calculate distance to Medial Axis ..." << endl;
+
+    const pointField& points = mesh_.points();
+    const pointMesh& pMesh = meshMover.pMesh();
+
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const vectorField& faceNormals = pp.faceNormals();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Predetermine mesh edges
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Precalulate master edge (only relevant for shared edges)
+    PackedList<1> isMasterEdge(syncTools::getMasterEdges(mesh_));
+    // Precalculate meshEdge per pp edge
+    labelList meshEdges(pp.nEdges());
+
+    forAll(meshEdges, patchEdgeI)
+    {
+        const edge& e = pp.edges()[patchEdgeI];
+
+        label v0 = pp.meshPoints()[e[0]];
+        label v1 = pp.meshPoints()[e[1]];
+        meshEdges[patchEdgeI] = meshTools::findEdge
+        (
+            mesh_.edges(),
+            mesh_.pointEdges()[v0],
+            v0,
+            v1
+        );
+    }
+
+
+    // Determine pointNormal
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    pointField pointNormals(pp.nPoints(), vector::zero);
+    {
+        labelList nPointFaces(pp.nPoints(), 0);
+
+        forAll(faceNormals, faceI)
+        {
+            const face& f = pp.localFaces()[faceI];
+
+            forAll(f, fp)
+            {
+                pointNormals[f[fp]] += faceNormals[faceI];
+                nPointFaces[f[fp]] ++;
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            pointNormals,
+            plusEqOp<vector>(),
+            vector::zero,       // null value
+            false               // no separation
+        );
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            meshPoints,
+            nPointFaces,
+            plusEqOp<label>(),
+            0,                  // null value
+            false               // no separation
+        );
+
+        forAll(pointNormals, i)
+        {
+            pointNormals[i] /= nPointFaces[i];
+        }
+    }
+
+    // Smooth patch normal vectors
+    smoothPatchNormals
+    (
+        meshMover,
+        isMasterEdge,
+        meshEdges,
+        nSmoothSurfaceNormals,
+        pointNormals
+    );
+
+
+    // Calculate distance to pp points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Distance to wall
+    List<pointData> pointWallDist(mesh_.nPoints());
+
+
+    // 1. Calculate distance to points where displacement is specified.
+    {
+        // Seed data.
+        List<pointData> wallInfo(meshPoints.size());
+
+        forAll(meshPoints, patchPointI)
+        {
+            label pointI = meshPoints[patchPointI];
+            wallInfo[patchPointI] = pointData
+            (
+                points[pointI],
+                0.0,
+                pointI,                       // passive scalar
+                pointNormals[patchPointI]     // surface normals
+            );
+        }
+
+        // Do all calculations
+        List<pointData> edgeWallDist(mesh_.nEdges());
+        PointEdgeWave<pointData> wallDistCalc
+        (
+            pMesh,
+            meshPoints,
+            wallInfo,
+            pointWallDist,
+            edgeWallDist,
+            mesh_.nPoints()  // max iterations
+        );
+    }
+
+    // 2. Find points with max distance and transport information back to
+    //    wall.
+    {
+        List<pointData> pointMedialDist(mesh_.nPoints());
+        List<pointData> edgeMedialDist(mesh_.nEdges());
+
+        // Seed point data.
+        DynamicList<pointData> maxInfo(meshPoints.size());
+        DynamicList<label> maxPoints(meshPoints.size());
+
+        // 1. Medial axis points
+
+        const edgeList& edges = mesh_.edges();
+
+        forAll(edges, edgeI)
+        {
+            if (isMaxEdge(pointWallDist, edgeI, minMedianAxisAngleCos))
+            {
+                // Both end points of edge have very different nearest wall
+                // point. Mark both points as medial axis points.
+                const edge& e = edges[edgeI];
+
+                forAll(e, ep)
+                {
+                    label pointI = e[ep];
+
+                    if (!pointMedialDist[pointI].valid())
+                    {
+                        maxPoints.append(pointI);
+                        maxInfo.append
+                        (
+                            pointData
+                            (
+                                points[pointI],
+                                0.0,
+                                pointI,         // passive data
+                                vector::zero    // passive data
+                            )
+                        );
+                        pointMedialDist[pointI] = maxInfo[maxInfo.size()-1];
+                    }
+                }
+            }
+        }
+
+
+        // 2. Seed non-adapt patches
+        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+        labelHashSet adaptPatches(meshMover.adaptPatchIDs());
+
+        forAll(patches, patchI)
+        {
+            const polyPatch& pp = patches[patchI];
+
+            if
+            (
+                !pp.coupled()
+             && !isA<emptyPolyPatch>(pp)
+             && !adaptPatches.found(patchI)
+            )
+            {
+                Info<< "Inserting points on patch " << pp.name() << endl;
+
+                const labelList& meshPoints = pp.meshPoints();
+
+                forAll(meshPoints, i)
+                {
+                    label pointI = meshPoints[i];
+
+                    if (!pointMedialDist[pointI].valid())
+                    {
+                        maxPoints.append(pointI);
+                        maxInfo.append
+                        (
+                            pointData
+                            (
+                                points[pointI],
+                                0.0,
+                                pointI,         // passive data
+                                vector::zero    // passive data
+                            )
+                        );
+                        pointMedialDist[pointI] = maxInfo[maxInfo.size()-1];
+                    }
+                }
+            }
+        }
+
+        maxInfo.shrink();
+        maxPoints.shrink();
+
+        // Do all calculations
+        PointEdgeWave<pointData> medialDistCalc
+        (
+            pMesh,
+            maxPoints,
+            maxInfo,
+
+            pointMedialDist,
+            edgeMedialDist,
+            mesh_.nPoints()  // max iterations
+        );
+
+        // Extract medial axis distance as pointScalarField
+        forAll(pointMedialDist, pointI)
+        {
+            medialDist[pointI] = Foam::sqrt(pointMedialDist[pointI].distSqr());
+        }
+    }
+
+    // Extract transported surface normals as pointVectorField
+    forAll(dispVec, i)
+    {
+        dispVec[i] = pointWallDist[i].v();
+    }
+
+    // Smooth normal vectors. Do not change normals on pp.meshPoints
+    smoothNormals(nSmoothNormals, isMasterEdge, meshPoints, dispVec);
+
+    // Calculate ratio point medial distance to point wall distance
+    forAll(medialRatio, pointI)
+    {
+        scalar wDist2 = pointWallDist[pointI].distSqr();
+        scalar mDist = medialDist[pointI];
+
+        if (wDist2 < sqr(SMALL) && mDist < SMALL)
+        {
+            medialRatio[pointI] = 0.0;
+        }
+        else
+        {
+            medialRatio[pointI] = mDist / (Foam::sqrt(wDist2) + mDist);
+        }
+    }
+
+    if (debug_)
+    {
+        Info<< "medialAxisSmoothingInfo :"
+            << " Writing:" << nl
+            << "    " << dispVec.name()
+            << " : normalised direction of nearest displacement" << nl
+            << "    " << medialDist.name()
+            << " : distance to medial axis" << nl
+            << "    " << medialRatio.name()
+            << " : ratio of medial distance to wall distance" << nl
+            << endl;
+        dispVec.write();
+        medialDist.write();
+        medialRatio.write();
+    }
+}
+
+
+void Foam::autoHexMeshDriver::shrinkMeshMedialDistance
+(
+    motionSmoother& meshMover,
+    const label nSmoothThickness,
+    const scalar maxThicknessToMedialRatio,
+    const label nAllowableErrors,
+    const label nSnap,
+    const scalar minCosLayerTermination,
+
+    const scalarField& layerThickness,
+    const scalarField& minThickness,
+
+    const pointVectorField& dispVec,
+    const pointScalarField& medialRatio,
+    const pointScalarField& medialDist,
+
+    List<extrudeMode>& extrudeStatus,
+    pointField& patchDisp,
+    labelList& patchNLayers
+) const
+{
+    Info<< "shrinkMeshMedialDistance : Smoothing using Medial Axis ..." << endl;
+
+    const polyMesh& mesh = meshMover.mesh();
+    const pointMesh& pMesh = meshMover.pMesh();
+
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Precalulate master edge (only relevant for shared edges)
+    PackedList<1> isMasterEdge(syncTools::getMasterEdges(mesh_));
+    // Precalculate meshEdge per pp edge
+    labelList meshEdges(pp.nEdges());
+
+    forAll(meshEdges, patchEdgeI)
+    {
+        const edge& e = pp.edges()[patchEdgeI];
+
+        label v0 = pp.meshPoints()[e[0]];
+        label v1 = pp.meshPoints()[e[1]];
+        meshEdges[patchEdgeI] = meshTools::findEdge
+        (
+            mesh_.edges(),
+            mesh_.pointEdges()[v0],
+            v0,
+            v1
+        );
+    }
+
+
+    scalarField thickness(layerThickness.size());
+
+    thickness = mag(patchDisp);
+
+    forAll(thickness, patchPointI)
+    {
+        if (extrudeStatus[patchPointI] == NOEXTRUDE)
+        {
+            thickness[patchPointI] = 0.0;
+        }
+    }
+
+    label numThicknessRatioExclude = 0;
+
+    // reduce thickness where thickness/medial axis distance large
+    forAll(meshPoints, patchPointI)
+    {
+        if (extrudeStatus[patchPointI] != NOEXTRUDE)
+        {
+            label pointI = meshPoints[patchPointI];
+
+            scalar mDist = medialDist[pointI];
+
+            scalar thicknessRatio = thickness[patchPointI]/(mDist+VSMALL);
+
+            if (thicknessRatio > maxThicknessToMedialRatio)
+            {
+                // Truncate thickness.
+                thickness[patchPointI] =
+                    0.5*(minThickness[patchPointI]+thickness[patchPointI]);
+
+                patchDisp[patchPointI] =
+                    thickness[patchPointI]
+                  * patchDisp[patchPointI]
+                  / (mag(patchDisp[patchPointI]) + VSMALL);
+                numThicknessRatioExclude++;
+            }
+        }
+    }
+
+    reduce(numThicknessRatioExclude, sumOp<label>());
+    Info<< "shrinkMeshMedialDistance : Reduce layer thickness at "
+        << numThicknessRatioExclude
+        << " nodes where thickness to medial axis distance is large " << endl;
+
+    // find points where layer growth isolated to a lone point, edge or face
+
+    findIsolatedRegions
+    (
+        pp,
+        isMasterEdge,
+        meshEdges,
+        minCosLayerTermination,
+        thickness,
+        extrudeStatus,
+        patchDisp,
+        patchNLayers
+    );
+
+    // smooth layer thickness on moving patch
+    smoothField
+    (
+        meshMover,
+        isMasterEdge,
+        meshEdges,
+        minThickness,
+        nSmoothThickness,
+        thickness
+    );
+
+    List<pointData> pointWallDist(mesh.nPoints());
+
+    const pointField& points = mesh.points();
+    // 1. Calculate distance to points where displacement is specified.
+    // This wave is used to transport layer thickness
+    {
+        // Distance to wall and medial axis on edges.
+        List<pointData> edgeWallDist(mesh.nEdges());
+        labelList wallPoints(meshPoints.size());
+
+        // Seed data.
+        List<pointData> wallInfo(meshPoints.size());
+
+        forAll(meshPoints, patchPointI)
+        {
+            label pointI = meshPoints[patchPointI];
+            wallPoints[patchPointI] = pointI;
+            wallInfo[patchPointI] = pointData
+            (
+                points[pointI],
+                0.0,
+                thickness[patchPointI],       // transport layer thickness
+                vector::zero                  // passive vector
+            );
+        }
+
+        // Do all calculations
+        PointEdgeWave<pointData> wallDistCalc
+        (
+            pMesh,
+            wallPoints,
+            wallInfo,
+            pointWallDist,
+            edgeWallDist,
+            mesh.nPoints()  // max iterations
+        );
+    }
+
+    // Calculate scaled displacement vector
+    pointVectorField& displacement = meshMover.displacement();
+
+    forAll(displacement, pointI)
+    {
+        // 1) displacement on nearest wall point, scaled by medialRatio
+        //    (wall distance / medial distance)
+        // 2) pointWallDist[pointI].s() is layer thickness transported
+        //    from closest wall point.
+        // 3) shrink in opposite direction of addedPoints
+        displacement[pointI] =
+            -medialRatio[pointI]
+            *pointWallDist[pointI].s()
+            *dispVec[pointI];
+    }
+
+    // Current faces to check. Gets modified in meshMover.scaleMesh
+    labelList checkFaces(identity(mesh.nFaces()));
+
+    Info<< "shrinkMeshMedialDistance : Moving mesh ..." << endl;
+    scalar oldErrorReduction = -1;
+
+    for (label iter = 0; iter < 2*nSnap ; iter++)
+    {
+        Info<< "Iteration " << iter << endl;
+        if (iter == nSnap)
+        {
+            Info<< "Displacement scaling for error reduction set to 0." << endl;
+            oldErrorReduction = meshMover.setErrorReduction(0.0);
+        }
+
+        if (meshMover.scaleMesh(checkFaces, true, nAllowableErrors))
+        {
+            Info<< "shrinkMeshMedialDistance : Successfully moved mesh" << endl;
+            break;
+        }
+    }
+
+    if (oldErrorReduction >= 0)
+    {
+        meshMover.setErrorReduction(oldErrorReduction);
+    }
+
+    Info<< "shrinkMeshMedialDistance : Finished moving mesh ..." << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
new file mode 100644
index 0000000000..6e9c625a82
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
@@ -0,0 +1,1196 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+    All to do with snapping to the surface
+
+\*----------------------------------------------------------------------------*/
+
+#include "autoHexMeshDriver.H"
+#include "syncTools.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "OFstream.H"
+#include "mapPolyMesh.H"
+#include "motionSmoother.H"
+#include "pointEdgePoint.H"
+#include "PointEdgeWave.H"
+#include "mergePoints.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::autoHexMeshDriver::getZonedSurfaces
+(
+    labelList& zonedSurfaces,
+    labelList& unzonedSurfaces
+) const
+{    // Surfaces with zone information
+    const wordList& faceZoneNames = surfaces().faceZoneNames();
+
+    zonedSurfaces.setSize(faceZoneNames.size());
+    label zonedI = 0;
+    unzonedSurfaces.setSize(faceZoneNames.size());
+    label unzonedI = 0;
+
+    forAll(faceZoneNames, surfI)
+    {
+        if (faceZoneNames[surfI].size() > 0)
+        {
+            zonedSurfaces[zonedI++] = surfI;
+        }
+        else
+        {
+            unzonedSurfaces[unzonedI++] = surfI;
+        }
+    }
+    zonedSurfaces.setSize(zonedI);
+    unzonedSurfaces.setSize(unzonedI);
+}
+
+
+// Get faces to repatch. Returns map from face to patch.
+Foam::Map<Foam::label> Foam::autoHexMeshDriver::getZoneBafflePatches
+(
+    const bool allowBoundary
+) const
+{
+    Map<label> bafflePatch(mesh_.nFaces()/1000);
+
+    const wordList& faceZoneNames = surfaces().faceZoneNames();
+    const faceZoneMesh& fZones = mesh_.faceZones();
+
+    forAll(faceZoneNames, surfI)
+    {
+        if (faceZoneNames[surfI].size() > 0)
+        {
+            // Get zone
+            label zoneI = fZones.findZoneID(faceZoneNames[surfI]);
+
+            const faceZone& fZone = fZones[zoneI];
+
+            //// Get patch allocated for zone
+            //label patchI = surfaceToCyclicPatch_[surfI];
+            // Get patch of (first region) of surface
+            label patchI = globalToPatch_[surfaces().globalRegion(surfI, 0)];
+
+            Info<< "For surface "
+                << surfaces()[surfI].IOobject::name()
+                //<< surfaces().names()[surfI]
+                << " found faceZone " << fZone.name()
+                << " and patch " << mesh_.boundaryMesh()[patchI].name()
+                << endl;
+
+
+            forAll(fZone, i)
+            {
+                label faceI = fZone[i];
+
+                if (allowBoundary || mesh_.isInternalFace(faceI))
+                {
+                    if (!bafflePatch.insert(faceI, patchI))
+                    {
+                        label oldPatchI = bafflePatch[faceI];
+
+                        if (oldPatchI != patchI)
+                        {
+                            FatalErrorIn("getZoneBafflePatches(const bool)")
+                                << "Face " << faceI
+                                << " fc:" << mesh_.faceCentres()[faceI]
+                                << " is in faceZone "
+                                << mesh_.boundaryMesh()[oldPatchI].name()
+                                << " and in faceZone "
+                                << mesh_.boundaryMesh()[patchI].name()
+                                << abort(FatalError);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return bafflePatch;
+}
+
+
+// Calculate geometrically collocated points, Requires PackedList to be
+// sizes and initalised!
+Foam::label Foam::autoHexMeshDriver::getCollocatedPoints
+(
+    const scalar tol,
+    const pointField& points,
+    PackedList<1>& isCollocatedPoint
+)
+{
+    labelList pointMap;
+    pointField newPoints;
+    bool hasMerged = mergePoints
+    (
+        points,                         // points
+        tol,                            // mergeTol
+        false,                          // verbose
+        pointMap,
+        newPoints
+    );
+
+    if (!returnReduce(hasMerged, orOp<bool>()))
+    {
+        return 0;
+    }
+
+    // Determine which newPoints are referenced more than once
+    label nCollocated = 0;
+
+    // Per old point the newPoint. Or -1 (not set yet) or -2 (already seen
+    // twice)
+    labelList firstOldPoint(newPoints.size(), -1);
+    forAll(pointMap, oldPointI)
+    {
+        label newPointI = pointMap[oldPointI];
+
+        if (firstOldPoint[newPointI] == -1)
+        {
+            // First use of oldPointI. Store.
+            firstOldPoint[newPointI] = oldPointI;
+        }
+        else if (firstOldPoint[newPointI] == -2)
+        {
+            // Third or more reference of oldPointI -> non-manifold
+            isCollocatedPoint.set(oldPointI, 1u);
+            nCollocated++;
+        }
+        else
+        {
+            // Second reference of oldPointI -> non-manifold
+            isCollocatedPoint.set(firstOldPoint[newPointI], 1u);
+            nCollocated++;
+
+            isCollocatedPoint.set(oldPointI, 1u);
+            nCollocated++;
+
+            // Mark with special value to save checking next time round
+            firstOldPoint[newPointI] = -2;
+        }
+    }
+    return returnReduce(nCollocated, sumOp<label>());
+}
+
+
+// Calculate displacement as average of patch points.
+Foam::pointField Foam::autoHexMeshDriver::smoothPatchDisplacement
+(
+    const motionSmoother& meshMover
+) const
+{
+    const indirectPrimitivePatch& pp = meshMover.patch();
+
+    // Calculate geometrically non-manifold points on the patch to be moved.
+    PackedList<1> nonManifoldPoint(pp.nPoints());
+    label nNonManifoldPoints = getCollocatedPoints
+    (
+        SMALL,
+        pp.localPoints(),
+        nonManifoldPoint
+    );
+    Info<< "Found " << nNonManifoldPoints << " non-mainfold point(s)."
+        << endl;
+
+
+    // Average points
+    // ~~~~~~~~~~~~~~
+
+    // We determine three points:
+    // - average of (centres of) connected patch faces
+    // - average of (centres of) connected internal mesh faces
+    // - as fallback: centre of any connected cell
+    // so we can do something moderately sensible for non/manifold points.
+
+    // Note: the averages are calculated properly parallel. This is
+    // necessary to get the points shared by processors correct.
+
+
+    const labelListList& pointFaces = pp.pointFaces();
+    const labelList& meshPoints = pp.meshPoints();
+    const pointField& points = pp.points();
+    const polyMesh& mesh = meshMover.mesh();
+
+
+    // Get average position of boundary face centres
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    vectorField avgBoundary(pointFaces.size(), vector::zero);
+    labelList nBoundary(pointFaces.size(), 0);
+
+    forAll(pointFaces, patchPointI)
+    {
+        const labelList& pFaces = pointFaces[patchPointI];
+
+        forAll(pFaces, pfI)
+        {
+            avgBoundary[patchPointI] += pp[pFaces[pfI]].centre(points);
+        }
+        nBoundary[patchPointI] = pFaces.size();
+    }
+
+    syncTools::syncPointList
+    (
+        mesh,
+        pp.meshPoints(),
+        avgBoundary,
+        plusEqOp<point>(),  // combine op
+        vector::zero,       // null value
+        false               // no separation
+    );
+    syncTools::syncPointList
+    (
+        mesh,
+        pp.meshPoints(),
+        nBoundary,
+        plusEqOp<label>(),  // combine op
+        0,                  // null value
+        false               // no separation
+    );
+
+    forAll(avgBoundary, i)
+    {
+        avgBoundary[i] /= nBoundary[i];
+    }
+
+
+    // Get average position of internal face centres
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    vectorField avgInternal;
+    labelList nInternal;
+    {
+        vectorField globalSum(mesh.nPoints(), vector::zero);
+        labelList globalNum(mesh.nPoints(), 0);
+
+        // Note: no use of pointFaces
+        const faceList& faces = mesh.faces();
+
+        for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+        {
+            const face& f = faces[faceI];
+            const point& fc = mesh.faceCentres()[faceI];
+
+            forAll(f, fp)
+            {
+                globalSum[f[fp]] += fc;
+                globalNum[f[fp]]++;
+            }
+        }
+
+        // Count coupled faces as internal ones (but only once)
+        const polyBoundaryMesh& patches = mesh.boundaryMesh();
+
+        forAll(patches, patchI)
+        {
+            if (Pstream::parRun() && isA<processorPolyPatch>(patches[patchI]))
+            {
+                const processorPolyPatch& pp =
+                    refCast<const processorPolyPatch>(patches[patchI]);
+
+                if (pp.myProcNo() < pp.neighbProcNo())
+                {
+                    const vectorField::subField faceCentres = pp.faceCentres();
+
+                    forAll(pp, i)
+                    {
+                        const face& f = pp[i];
+                        const point& fc = faceCentres[i];
+
+                        forAll(f, fp)
+                        {
+                            globalSum[f[fp]] += fc;
+                            globalNum[f[fp]]++;
+                        }
+                    }
+                }
+            }
+            else if (isA<cyclicPolyPatch>(patches[patchI]))
+            {
+                const cyclicPolyPatch& pp =
+                    refCast<const cyclicPolyPatch>(patches[patchI]);
+
+                const vectorField::subField faceCentres = pp.faceCentres();
+
+                for (label i = 0; i < pp.size()/2; i++)
+                {
+                    const face& f = pp[i];
+                    const point& fc = faceCentres[i];
+
+                    forAll(f, fp)
+                    {
+                        globalSum[f[fp]] += fc;
+                        globalNum[f[fp]]++;
+                    }
+                }
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh,
+            globalSum,
+            plusEqOp<vector>(), // combine op
+            vector::zero,       // null value
+            false               // no separation
+        );
+        syncTools::syncPointList
+        (
+            mesh,
+            globalNum,
+            plusEqOp<label>(),  // combine op
+            0,                  // null value
+            false               // no separation
+        );
+
+        avgInternal.setSize(meshPoints.size());
+        nInternal.setSize(meshPoints.size());
+
+        forAll(avgInternal, patchPointI)
+        {
+            label meshPointI = meshPoints[patchPointI];
+
+            nInternal[patchPointI] = globalNum[meshPointI];
+
+            if (nInternal[patchPointI] == 0)
+            {
+                avgInternal[patchPointI] = globalSum[meshPointI];
+            }
+            else
+            {
+                avgInternal[patchPointI] =
+                    globalSum[meshPointI]
+                  / nInternal[patchPointI];
+            }
+        }
+    }
+
+
+    // Precalculate any cell using mesh point (replacement of pointCells()[])
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList anyCell(mesh.nPoints(), -1);
+    forAll(mesh.faceNeighbour(), faceI)
+    {
+        label own = mesh.faceOwner()[faceI];
+        const face& f = mesh.faces()[faceI];
+
+        forAll(f, fp)
+        {
+            anyCell[f[fp]] = own;
+        }
+    }
+    for (label faceI = mesh.nInternalFaces(); faceI < mesh.nFaces(); faceI++)
+    {
+        label own = mesh.faceOwner()[faceI];
+
+        const face& f = mesh.faces()[faceI];
+
+        forAll(f, fp)
+        {
+            anyCell[f[fp]] = own;
+        }
+    }
+
+
+    // Displacement to calculate.
+    pointField patchDisp(meshPoints.size(), vector::zero);
+
+    forAll(pointFaces, i)
+    {
+        label meshPointI = meshPoints[i];
+        const point& currentPos = pp.points()[meshPointI];
+
+        // Now we have the two average points: avgBoundary and avgInternal
+        // and how many boundary/internal faces connect to the point
+        // (nBoundary, nInternal)
+        // Do some blending between the two.
+        // Note: the following section has some reasoning behind it but the
+        // blending factors can be experimented with.
+
+        point newPos;
+
+        if (nonManifoldPoint.get(i) == 0u)
+        {
+            // Points that are manifold. Weight the internal and boundary
+            // by their number of faces and blend with
+            scalar internalBlend = 0.1;
+            scalar blend = 0.1;
+
+            point avgPos =
+                (
+                   internalBlend*nInternal[i]*avgInternal[i]
+                  +(1-internalBlend)*nBoundary[i]*avgBoundary[i]
+                )
+              / (internalBlend*nInternal[i]+(1-internalBlend)*nBoundary[i]);
+
+            newPos = (1-blend)*avgPos + blend*currentPos;
+        }
+        else if (nInternal[i] == 0)
+        {
+            // Non-manifold without internal faces. Use any connected cell
+            // as internal point instead. Use precalculated any cell to avoid
+            // e.g. pointCells()[meshPointI][0]
+
+            const point& cc = mesh.cellCentres()[anyCell[meshPointI]];
+
+            scalar cellCBlend = 0.8;
+            scalar blend = 0.1;
+
+            point avgPos = (1-cellCBlend)*avgBoundary[i] + cellCBlend*cc;
+
+            newPos = (1-blend)*avgPos + blend*currentPos;
+        }
+        else
+        {
+            // Non-manifold point with internal faces connected to them
+            scalar internalBlend = 0.9;
+            scalar blend = 0.1;
+
+            point avgPos =
+                internalBlend*avgInternal[i]
+              + (1-internalBlend)*avgBoundary[i];
+
+            newPos = (1-blend)*avgPos + blend*currentPos;
+        }
+
+        patchDisp[i] = newPos - currentPos;
+    }
+
+    return patchDisp;
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::autoHexMeshDriver::edgePatchDist
+(
+    const pointMesh& pMesh,
+    const indirectPrimitivePatch& pp
+)
+{
+    const polyMesh& mesh = pMesh();
+
+    // Set initial changed points to all the patch points
+    List<pointEdgePoint> wallInfo(pp.nPoints());
+
+    forAll(pp.localPoints(), ppI)
+    {
+        wallInfo[ppI] = pointEdgePoint(pp.localPoints()[ppI], 0.0);
+    }
+
+    // Current info on points
+    List<pointEdgePoint> allPointInfo(mesh.nPoints());
+
+    // Current info on edges
+    List<pointEdgePoint> allEdgeInfo(mesh.nEdges());
+
+    PointEdgeWave<pointEdgePoint> wallCalc
+    (
+        pMesh,
+        pp.meshPoints(),
+        wallInfo,
+
+        allPointInfo,
+        allEdgeInfo,
+        mesh.globalData().nTotalPoints()  // max iterations
+    );
+
+    // Copy edge values into scalarField
+    tmp<scalarField> tedgeDist(new scalarField(mesh.nEdges()));
+    scalarField& edgeDist = tedgeDist();
+
+    forAll(allEdgeInfo, edgeI)
+    {
+        edgeDist[edgeI] = Foam::sqrt(allEdgeInfo[edgeI].distSqr());
+    }
+
+
+    //{
+    //    // For debugging: dump to file
+    //    pointScalarField pointDist
+    //    (
+    //        IOobject
+    //        (
+    //            "pointDist",
+    //            mesh.DB().timeName(),
+    //            mesh.DB(),
+    //            IOobject::NO_READ,
+    //            IOobject::AUTO_WRITE
+    //        ),
+    //        pMesh,
+    //        dimensionedScalar("pointDist", dimless, 0.0)
+    //    );
+    //
+    //    forAll(allEdgeInfo, edgeI)
+    //    {
+    //        scalar d = Foam::sqrt(allEdgeInfo[edgeI].distSqr());
+    //
+    //        const edge& e = mesh.edges()[edgeI];
+    //
+    //        pointDist[e[0]] += d;
+    //        pointDist[e[1]] += d;
+    //    }
+    //    forAll(pointDist, pointI)
+    //    {
+    //        pointDist[pointI] /= mesh.pointEdges()[pointI].size();
+    //    }
+    //    Info<< "Writing patch distance to " << pointDist.name()
+    //        << " at time " << mesh.DB().timeName() << endl;
+    //
+    //    pointDist.write();
+    //}
+
+    return tedgeDist;
+}
+
+
+void Foam::autoHexMeshDriver::dumpMove
+(
+    const fileName& fName,
+    const pointField& meshPts,
+    const pointField& surfPts
+)
+{
+    // Dump direction of growth into file
+    Pout<< nl << "Dumping move direction to " << fName << nl
+        << "View this Lightwave-OBJ file with e.g. javaview" << nl
+        << endl;
+
+    OFstream nearestStream(fName);
+
+    label vertI = 0;
+
+    forAll(meshPts, ptI)
+    {
+        meshTools::writeOBJ(nearestStream, meshPts[ptI]);
+        vertI++;
+
+        meshTools::writeOBJ(nearestStream, surfPts[ptI]);
+        vertI++;
+
+        nearestStream<< "l " << vertI-1 << ' ' << vertI << nl;
+    }
+}
+
+
+// Check whether all displacement vectors point outwards of patch. Return true
+// if so.
+bool Foam::autoHexMeshDriver::outwardsDisplacement
+(
+    const indirectPrimitivePatch& pp,
+    const vectorField& patchDisp
+)
+{
+    const vectorField& faceNormals = pp.faceNormals();
+    const labelListList& pointFaces = pp.pointFaces();
+
+    forAll(pointFaces, pointI)
+    {
+        const labelList& pFaces = pointFaces[pointI];
+
+        vector disp(patchDisp[pointI]);
+
+        scalar magDisp = mag(disp);
+
+        if (magDisp > SMALL)
+        {
+            disp /= magDisp;
+
+            bool outwards = meshTools::visNormal(disp, faceNormals, pFaces);
+
+            if (!outwards)
+            {
+                Warning<< "Displacement " << patchDisp[pointI]
+                    << " at mesh point " << pp.meshPoints()[pointI]
+                    << " coord " << pp.points()[pp.meshPoints()[pointI]]
+                    << " points through the surrounding patch faces" << endl;
+                return false;
+            }
+        }
+        else
+        {
+            //? Displacement small but in wrong direction. Would probably be ok.
+        }
+    }
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::createZoneBaffles
+(
+    List<labelPair>& baffles
+)
+{
+    labelList zonedSurfaces;
+    labelList unzonedSurfaces;
+    getZonedSurfaces(zonedSurfaces, unzonedSurfaces);
+
+    autoPtr<mapPolyMesh> map;
+
+    // No need to sync; all processors will have all same zonedSurfaces.
+    if (zonedSurfaces.size() > 0)
+    {
+        // Split internal faces on interface surfaces
+        Info<< "Converting zoned faces into baffles ..." << endl;
+
+        // Get faces (internal only) to be baffled. Map from face to patch
+        // label.
+        Map<label> faceToPatch(getZoneBafflePatches(false));
+
+        label nZoneFaces = returnReduce(faceToPatch.size(), sumOp<label>());
+        if (nZoneFaces > 0)
+        {
+            // Convert into labelLists
+            labelList ownPatch(mesh_.nFaces(), -1);
+            forAllConstIter(Map<label>, faceToPatch, iter)
+            {
+                ownPatch[iter.key()] = iter();
+            }
+
+            // Create baffles. both sides same patch.
+            map = meshRefinerPtr_().createBaffles(ownPatch, ownPatch);
+
+            // Get pairs of faces created.
+            // Just loop over faceMap and store baffle if we encounter a slave
+            // face.
+
+            baffles.setSize(faceToPatch.size());
+            label baffleI = 0;
+
+            const labelList& faceMap = map().faceMap();
+            const labelList& reverseFaceMap = map().reverseFaceMap();
+
+            forAll(faceMap, faceI)
+            {
+                label oldFaceI = faceMap[faceI];
+
+                // Does face originate from face-to-patch
+                Map<label>::const_iterator iter = faceToPatch.find(oldFaceI);
+
+                if (iter != faceToPatch.end())
+                {
+                    label masterFaceI = reverseFaceMap[oldFaceI];
+                    if (faceI != masterFaceI)
+                    {
+                        baffles[baffleI++] = labelPair(masterFaceI, faceI);
+                    }
+                }
+            }
+
+            if (baffleI != faceToPatch.size())
+            {
+                FatalErrorIn("autoHexMeshDriver::createZoneBaffles(..)")
+                    << "Had " << faceToPatch.size() << " patches to create "
+                    << " but encountered " << baffleI
+                    << " slave faces originating from patcheable faces."
+                    << abort(FatalError);
+            }
+
+            if (debug_)
+            {
+                const_cast<Time&>(mesh_.time())++;
+                Pout<< "Writing baffled mesh to time " << mesh_.time().timeName()
+                    << endl;
+                mesh_.write();
+            }
+        }
+        Info<< "Created " << nZoneFaces << " baffles in = "
+            << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+    return map;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::mergeZoneBaffles
+(
+    const List<labelPair>& baffles
+)
+{
+    labelList zonedSurfaces;
+    labelList unzonedSurfaces;
+    getZonedSurfaces(zonedSurfaces, unzonedSurfaces);
+
+    autoPtr<mapPolyMesh> map;
+
+    // No need to sync; all processors will have all same zonedSurfaces.
+    label nBaffles = returnReduce(baffles.size(), sumOp<label>());
+    if (zonedSurfaces.size() > 0 && nBaffles > 0)
+    {
+        // Merge any baffles
+        Info<< "Converting " << nBaffles << " baffles back into zoned faces ..."
+            << endl;
+
+        map = meshRefinerPtr_().mergeBaffles(baffles);
+
+        Info<< "Converted baffles in = "
+            << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+
+    return map;
+}
+
+
+Foam::scalarField Foam::autoHexMeshDriver::calcSnapDistance
+(
+    const indirectPrimitivePatch& pp
+) const
+{
+    const dictionary& snapDict = dict_.subDict("snapDict");
+    // When to snap
+    scalar snapTol(readScalar(snapDict.lookup("snapTol")));
+
+
+    const edgeList& edges = pp.edges();
+    const labelListList& pointEdges = pp.pointEdges();
+    const pointField& localPoints = pp.localPoints();
+
+    scalarField maxEdgeLen(localPoints.size(), -GREAT);
+
+    forAll(pointEdges, pointI)
+    {
+        const labelList& pEdges = pointEdges[pointI];
+
+        forAll(pEdges, pEdgeI)
+        {
+            const edge& e = edges[pEdges[pEdgeI]];
+
+            scalar len = e.mag(localPoints);
+
+            maxEdgeLen[pointI] = max(maxEdgeLen[pointI], len);
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        maxEdgeLen,
+        maxEqOp<scalar>(),  // combine op
+        -GREAT,             // null value
+        false               // no separation
+    );
+
+    return snapTol*maxEdgeLen;
+}
+
+
+// Invert globalToPatch_ to get the patches related to surfaces.
+Foam::labelList Foam::autoHexMeshDriver::getSurfacePatches() const
+{
+    // Set of patches originating from surface
+    labelHashSet surfacePatchSet(surfaces().size());
+
+    forAll(globalToPatch_, i)
+    {
+        if (globalToPatch_[i] != -1)
+        {
+            surfacePatchSet.insert(globalToPatch_[i]);
+        }
+    }
+
+    DynamicList<label> surfacePatches(surfacePatchSet.size());
+
+    for (label patchI = 0; patchI < mesh_.boundaryMesh().size(); patchI++)
+    {
+        if (surfacePatchSet.found(patchI))
+        {
+            surfacePatches.append(patchI);
+        }
+    }
+    return surfacePatches.shrink();
+}
+
+
+void Foam::autoHexMeshDriver::preSmoothPatch
+(
+    const label nInitErrors,
+    const List<labelPair>& baffles,
+    motionSmoother& meshMover
+) const
+{
+    const dictionary& snapDict = dict_.subDict("snapDict");
+    // Smoothing iterations
+    label nSmoothPatch(readLabel(snapDict.lookup("nSmoothPatch")));
+    // Snapping iterations
+    label nSnap(readLabel(snapDict.lookup("nSnap")));
+
+    labelList checkFaces;
+
+    Info<< "Smoothing patch points ..." << endl;
+    for (label smoothIter = 0; smoothIter < nSmoothPatch; smoothIter++)
+    {
+        Info<< "Smoothing iteration " << smoothIter << endl;
+        checkFaces.setSize(mesh_.nFaces());
+        forAll(checkFaces, faceI)
+        {
+            checkFaces[faceI] = faceI;
+        }
+
+        pointField patchDisp(smoothPatchDisplacement(meshMover));
+
+        // The current mesh is the starting mesh to smooth from.
+        meshMover.setDisplacement(patchDisp);
+        meshMover.correct();
+
+        scalar oldErrorReduction = -1;
+
+        for (label snapIter = 0; snapIter < 2*nSnap; snapIter++)
+        {
+            Info<< nl << "Scaling iteration " << snapIter << endl;
+
+            if (snapIter == nSnap)
+            {
+                Info<< "Displacement scaling for error reduction set to 0."
+                    << endl;
+                oldErrorReduction = meshMover.setErrorReduction(0.0);
+            }
+
+            // Try to adapt mesh to obtain displacement by smoothly
+            // decreasing displacement at error locations.
+            if (meshMover.scaleMesh(checkFaces, baffles, true, nInitErrors))
+            {
+                Info<< "Successfully moved mesh" << endl;
+                break;
+            }
+        }
+
+        if (oldErrorReduction >= 0)
+        {
+            meshMover.setErrorReduction(oldErrorReduction);
+        }
+        Info<< endl;
+    }
+
+
+    // The current mesh is the starting mesh to smooth from.
+    meshMover.correct();
+
+    if (debug_)
+    {
+        Pout<< "Writing patch smoothed mesh to time " << mesh_.time().timeName()
+            << endl;
+        mesh_.write();
+    }
+
+    Info<< "Patch points smoothed in = "
+        << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+}
+
+
+Foam::vectorField Foam::autoHexMeshDriver::calcNearestSurface
+(
+    const scalarField& snapDist,
+    motionSmoother& meshMover
+) const
+{
+    Info<< "Calculating patchDisplacement as distance to nearest surface"
+        << " point ..." << endl;
+
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const pointField& localPoints = pp.localPoints();
+
+    // Divide surfaces into zoned and unzoned
+    labelList zonedSurfaces;
+    labelList unzonedSurfaces;
+    getZonedSurfaces(zonedSurfaces, unzonedSurfaces);
+
+    // Displacement per patch point
+    vectorField patchDisp(localPoints.size(), vector::zero);
+
+
+    // 1. All points to non-interface surfaces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(localPoints, pointI)
+    {
+        pointIndexHit pHit;
+
+        label surfI = surfaces().findNearest
+        (
+            unzonedSurfaces,
+            localPoints[pointI],
+            sqr(4*snapDist[pointI]),            // sqr of attract distance
+            pHit
+        );
+
+        if (surfI != -1)
+        {
+            patchDisp[pointI] = pHit.hitPoint() - localPoints[pointI];
+        }
+        //else
+        //{
+        //   WarningIn("autoHexMeshDriver::calcNearestSurface(..)")
+        //        << "For point:" << pointI
+        //        << " coordinate:" << localPoints[pointI]
+        //        << " did not find any surface within:" << 4*snapDist[pointI]
+        //        << " meter." << endl;
+        //}
+    }
+
+
+    // 2. All points on zones to their respective surface
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Surfaces with zone information
+    const wordList& faceZoneNames = surfaces().faceZoneNames();
+
+    forAll(zonedSurfaces, i)
+    {
+        label zoneSurfI = zonedSurfaces[i];
+
+        const labelList surfacesToTest(1, zoneSurfI);
+
+        label zoneI = mesh_.faceZones().findZoneID(faceZoneNames[zoneSurfI]);
+
+        const faceZone& fZone = mesh_.faceZones()[zoneI];
+
+        forAll(fZone, i)
+        {
+            const face& f = mesh_.faces()[fZone[i]];
+
+            forAll(f, fp)
+            {
+                label meshPointI = f[fp];
+
+                Map<label>::const_iterator iter =
+                    pp.meshPointMap().find(meshPointI);
+
+                if (iter != pp.meshPointMap().end())
+                {
+                    label pointI = iter();
+
+                    pointIndexHit pHit;
+
+                    label surfI = surfaces().findNearest
+                    (
+                        surfacesToTest,
+                        localPoints[pointI],
+                        sqr(4*snapDist[pointI]),    // sqr of attract distance
+                        pHit
+                    );
+
+                    if (surfI != -1)
+                    {
+                        patchDisp[pointI] =
+                            pHit.hitPoint() - localPoints[pointI];
+                    }
+                    else
+                    {
+                        WarningIn("autoHexMeshDriver::calcNearestSurface(..)")
+                            << "For point:" << pointI
+                            << " coordinate:" << localPoints[pointI]
+                            << " did not find any surface within:"
+                            << 4*snapDist[pointI]
+                            << " meter." << endl;
+                    }
+                }
+            }
+        }
+    }
+
+
+    {
+        scalarField magDisp(mag(patchDisp));
+
+        Info<< "Wanted displacement : average:"
+            << gSum(magDisp)/returnReduce(patchDisp.size(), sumOp<label>())
+            << " min:" << gMin(magDisp)
+            << " max:" << gMax(magDisp) << endl;
+    }
+
+    Info<< "Calculated surface displacement in = "
+        << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+
+
+    // Limit amount of movement.
+    forAll(patchDisp, patchPointI)
+    {
+        scalar magDisp = mag(patchDisp[patchPointI]);
+
+        if (magDisp > snapDist[patchPointI])
+        {
+            patchDisp[patchPointI] *= snapDist[patchPointI] / magDisp;
+
+            Pout<< "Limiting displacement for " << patchPointI
+                << " from " << magDisp << " to " << snapDist[patchPointI]
+                << endl;
+        }
+    }
+
+    // Points on zones in one domain but only present as point on other
+    // will not do condition 2 on all. Sync explicitly.
+    syncTools::syncPointList
+    (
+        mesh_,
+        pp.meshPoints(),
+        patchDisp,
+        minMagEqOp(),                   // combine op
+        vector(GREAT, GREAT, GREAT),    // null value
+        false                           // no separation
+    );
+
+
+    // Check for displacement being outwards.
+    outwardsDisplacement(pp, patchDisp);
+
+    // Set initial distribution of displacement field (on patches) from
+    // patchDisp and make displacement consistent with b.c. on displacement
+    // pointVectorField.
+    meshMover.setDisplacement(patchDisp);
+
+    if (debug_)
+    {
+        dumpMove
+        (
+            mesh_.time().path()/"patchDisplacement.obj",
+            pp.localPoints(),
+            pp.localPoints() + patchDisp
+        );
+    }
+
+    return patchDisp;
+}
+
+
+void Foam::autoHexMeshDriver::smoothDisplacement(motionSmoother& meshMover)
+ const
+{
+    const pointMesh& pMesh = meshMover.pMesh();
+    const indirectPrimitivePatch& pp = meshMover.patch();
+
+    Info<< "Smoothing displacement ..." << endl;
+
+    const dictionary& snapDict = dict_.subDict("snapDict");
+    // Smoothing iterations
+    label nSmoothDisp(readLabel(snapDict.lookup("nSmoothDispl")));
+
+    // Set edge diffusivity as inverse of distance to patch
+    scalarField edgeGamma(1.0/(edgePatchDist(pMesh, pp) + SMALL));
+    //scalarField edgeGamma(mesh_.nEdges(), 1.0);
+    //scalarField edgeGamma(wallGamma(mesh, pp, 10, 1));
+
+    // Get displacement field
+    pointVectorField& disp = meshMover.displacement();
+
+    for (label iter = 0; iter < nSmoothDisp; iter++)
+    {
+        if ((iter % 10) == 0)
+        {
+            Info<< "Iteration " << iter << endl;
+        }
+        pointVectorField oldDisp(disp);
+
+        meshMover.smooth(oldDisp, edgeGamma, false, disp);
+    }
+    Info<< "Displacement smoothed in = "
+        << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+
+    if (debug_)
+    {
+        Pout<< "Writing smoothed mesh to time " << mesh_.time().timeName()
+            << endl;
+        mesh_.write();
+
+        Pout<< "Writing displacement field ..." << endl;
+        disp.write();
+        tmp<pointScalarField> magDisp(mag(disp));
+        magDisp().write();
+
+        Pout<< "Writing actual patch displacement ..." << endl;
+        vectorField actualPatchDisp
+        (
+            IndirectList<point>(disp, pp.meshPoints())()
+        );
+        dumpMove
+        (
+            mesh_.time().path()/"actualPatchDisplacement.obj",
+            pp.localPoints(),
+            pp.localPoints() + actualPatchDisp
+        );
+    }
+}
+
+
+void Foam::autoHexMeshDriver::scaleMesh
+(
+    const label nInitErrors,
+    const List<labelPair>& baffles,
+    motionSmoother& meshMover
+)
+{
+    const dictionary& snapDict = dict_.subDict("snapDict");
+    // Snapping iterations
+    label nSnap(readLabel(snapDict.lookup("nSnap")));
+
+
+    // Relax displacement until correct mesh
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    labelList checkFaces(identity(mesh_.nFaces()));
+
+    scalar oldErrorReduction = -1;
+
+    Info<< "Moving mesh ..." << endl;
+    for (label iter = 0; iter < 2*nSnap; iter++)
+    {
+        Info<< nl << "Iteration " << iter << endl;
+
+        if (iter == nSnap)
+        {
+            Info<< "Displacement scaling for error reduction set to 0." << endl;
+            oldErrorReduction = meshMover.setErrorReduction(0.0);
+        }
+
+        if (meshMover.scaleMesh(checkFaces, baffles, true, nInitErrors))
+        {
+            Info<< "Successfully moved mesh" << endl;
+
+            break;
+        }
+        if (debug_)
+        {
+            Pout<< "Writing scaled mesh to time " << mesh_.time().timeName()
+                << endl;
+            mesh_.write();
+
+            Pout<< "Writing displacement field ..." << endl;
+            meshMover.displacement().write();
+            tmp<pointScalarField> magDisp(mag(meshMover.displacement()));
+            magDisp().write();
+
+            const_cast<Time&>(mesh_.time())++;
+        }
+    }
+
+    if (oldErrorReduction >= 0)
+    {
+        meshMover.setErrorReduction(oldErrorReduction);
+    }
+    Info<< "Moved mesh in = "
+        << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C
new file mode 100644
index 0000000000..91a42d3cfe
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C
@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "autoHexMeshDriver.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::autoHexMeshDriver::averageNeighbours
+(
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const labelList& meshPoints,
+    const edgeList& edges,
+    const scalarField& invSumWeight,
+    const Field<Type>& data,
+    Field<Type>& average
+) const
+{
+    average = pTraits<Type>::zero;
+
+    forAll(edges, edgeI)
+    {
+        if (isMasterEdge.get(meshEdges[edgeI]) == 1)
+        {
+            const edge& e = edges[edgeI];
+            //scalar eWeight = edgeWeights[edgeI];
+            scalar eWeight =  1.0;
+            label v0 = e[0];
+            label v1 = e[1];
+
+            average[v0] += eWeight*data[v1];
+            average[v1] += eWeight*data[v0];
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        meshPoints,
+        average,
+        plusEqOp<Type>(),
+        pTraits<Type>::zero,    // null value
+        false                   // no separation
+    );
+
+    average *= invSumWeight;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.C
new file mode 100644
index 0000000000..eabf4bbd16
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.C
@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "pointData.H"
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const pointData& wDist)
+{
+    if (os.format() == IOstream::ASCII)
+    {
+        return os
+            << wDist.origin() << token::SPACE << wDist.distSqr()
+            << token::SPACE << wDist.s() << token::SPACE << wDist.v();
+    }
+    else
+    {
+        return os
+            << wDist.origin() << wDist.distSqr() << wDist.s() << wDist.v();
+    }
+}
+
+Foam::Istream& Foam::operator>>(Istream& is, pointData& wDist)
+{
+    return is >> wDist.origin_ >> wDist.distSqr_ >> wDist.s_ >> wDist.v_;
+}
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.H
new file mode 100644
index 0000000000..e989184699
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointData.H
@@ -0,0 +1,228 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    pointData
+
+Description
+    Holds information regarding nearest wall point. Used in pointEdgeWave.
+    (so not standard meshWave)
+    To be used in wall distance calculation.
+
+SourceFiles
+    pointDataI.H
+    pointData.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef pointData_H
+#define pointData_H
+
+#include "point.H"
+#include "label.H"
+#include "scalar.H"
+#include "tensor.H"
+#include "pTraits.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class polyPatch;
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class pointData Declaration
+\*---------------------------------------------------------------------------*/
+
+class pointData
+{
+    // Private data
+
+        //- position of nearest wall center
+        point origin_;
+
+        //- normal distance (squared) from point to origin
+        scalar distSqr_;
+
+        //- additional information.
+        scalar s_;
+
+        //- additional information.
+        vector v_;
+
+
+    // Private Member Functions
+
+        //- Evaluate distance to point. Update distSqr, origin from whomever
+        //  is nearer pt. Return true if w2 is closer to point,
+        //  false otherwise.
+        inline bool update
+        (
+            const point&,
+            const pointData& w2,
+            const scalar tol
+        );
+
+        //- Combine current with w2. Update distSqr, origin if w2 has smaller
+        //  quantities and returns true.
+        inline bool update
+        (
+            const pointData& w2,
+            const scalar tol
+        );
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline pointData();
+
+        //- Construct from origin, distance
+        inline pointData
+        (
+            const point& origin,
+            const scalar distSqr,
+            const scalar s,
+            const vector& v
+        );
+
+        //- Construct as copy
+        inline pointData(const pointData&);
+
+
+    // Member Functions
+
+        // Access
+
+            inline const point& origin() const;
+
+            inline scalar distSqr() const;
+
+            inline scalar s() const;
+
+            inline const vector& v() const;
+
+
+        // Needed by meshWave
+
+            //- Check whether origin has been changed at all or
+            //  still contains original (invalid) value.
+            inline bool valid() const;
+
+            //- Check for identical geometrical data. Used for cyclics checking.
+            inline bool sameGeometry(const pointData&, const scalar tol)
+             const;
+
+            //- Convert origin to relative vector to leaving point
+            //  (= point coordinate)
+            inline void leaveDomain
+            (
+                const polyPatch& patch,
+                const label patchPointI,
+                const point& pos
+            );
+
+            //- Convert relative origin to absolute by adding entering point
+            inline void enterDomain
+            (
+                const polyPatch& patch,
+                const label patchPointI,
+                const point& pos
+            );
+
+            //- Apply rotation matrix to origin
+            inline void transform(const tensor& rotTensor);
+
+            //- Influence of edge on point
+            inline bool updatePoint
+            (
+                const polyMesh& mesh,
+                const label pointI,
+                const label edgeI,
+                const pointData& edgeInfo,
+                const scalar tol
+            );
+
+            //- Influence of different value on same point.
+            //  Merge new and old info.
+            inline bool updatePoint
+            (
+                const polyMesh& mesh,
+                const label pointI,
+                const pointData& newPointInfo,
+                const scalar tol
+            );
+
+            //- Influence of different value on same point.
+            //  No information about current position whatsoever.
+            inline bool updatePoint
+            (
+                const pointData& newPointInfo,
+                const scalar tol
+            );
+
+            //- Influence of point on edge.
+            inline bool updateEdge
+            (
+                const polyMesh& mesh,
+                const label edgeI,
+                const label pointI,
+                const pointData& pointInfo,
+                const scalar tol
+            );
+
+
+    // Member Operators
+
+        //Note: Used to determine whether to call update.
+        inline bool operator==(const pointData&) const;
+
+        inline bool operator!=(const pointData&) const;
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<<(Ostream&, const pointData&);
+        friend Istream& operator>>(Istream&, pointData&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "pointDataI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointDataI.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointDataI.H
new file mode 100644
index 0000000000..8b6c22f073
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/pointData/pointDataI.H
@@ -0,0 +1,356 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyMesh.H"
+#include "transform.H"
+#include "wallPoint.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Update this with w2 if w2 nearer to pt.
+inline bool Foam::pointData::update
+(
+    const point& pt,
+    const pointData& w2,
+    const scalar tol
+)
+{
+    scalar dist2 = magSqr(pt - w2.origin());
+
+    if (!valid())
+    {
+        distSqr_ = dist2;
+        origin_ = w2.origin();
+        s_ = w2.s();
+        v_ = w2.v();
+
+        return true;
+    }       
+
+
+//    if (v_ != w2.v())
+//    {
+//        return false;
+//    }
+
+
+    scalar diff = distSqr_ - dist2;
+
+    if (diff < 0)
+    {
+        // already nearer to pt
+        return false;
+    }
+
+    if ((diff < SMALL) || ((distSqr_ > SMALL) && (diff/distSqr_ < tol)))
+    {
+        // don't propagate small changes
+        return false;
+    }
+    else
+    {
+        // update with new values
+        distSqr_ = dist2;
+        origin_ = w2.origin();
+        s_ = w2.s();
+        v_ = w2.v();
+
+        return true;
+    }
+}
+
+    
+// Update this with w2 (information on same point)
+inline bool Foam::pointData::update
+(
+    const pointData& w2,
+    const scalar tol
+)
+{
+    if (!valid())
+    {
+        // current not yet set so use any value
+        distSqr_ = w2.distSqr();
+        origin_ = w2.origin();
+        s_ = w2.s();
+        v_ = w2.v();
+        return true;
+    }        
+
+
+//    if (v_ != w2.v())
+//    {
+//        return false;
+//    }
+
+
+    scalar diff = distSqr_ - w2.distSqr();
+
+    if (diff < 0)
+    {
+        // already nearer to pt
+        return false;
+    }
+
+    if ((diff < SMALL) || ((distSqr_ > SMALL) && (diff/distSqr_ < tol)))
+    {
+        // don't propagate small changes
+        return false;
+    }
+    else
+    {
+        // update with new values
+        distSqr_ =  w2.distSqr();
+        origin_ = w2.origin();
+        s_ = w2.s();
+        v_ = w2.v();
+
+        return true;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Null constructor
+inline Foam::pointData::pointData()
+:
+    origin_(wallPoint::greatPoint),
+    distSqr_(GREAT),
+    s_(GREAT),
+    v_(wallPoint::greatPoint)
+{}
+
+
+// Construct from origin, distance
+inline Foam::pointData::pointData
+(
+    const point& origin, 
+    const scalar distSqr,
+    const scalar s,
+    const vector& v
+)
+:
+    origin_(origin),
+    distSqr_(distSqr),
+    s_(s),
+    v_(v)
+{}
+
+
+// Construct as copy
+inline Foam::pointData::pointData(const pointData& wpt)
+:
+    origin_(wpt.origin()),
+    distSqr_(wpt.distSqr()),
+    s_(wpt.s()),
+    v_(wpt.v())
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::point& Foam::pointData::origin() const
+{
+    return origin_;
+}
+
+
+inline Foam::scalar Foam::pointData::distSqr() const
+{
+    return distSqr_;
+}
+
+
+inline Foam::scalar Foam::pointData::s() const
+{
+    return s_;
+}
+
+
+inline const Foam::vector& Foam::pointData::v() const
+{
+    return v_;
+}
+
+
+inline bool Foam::pointData::valid() const
+{
+    return origin_ != wallPoint::greatPoint;
+}
+
+
+// Checks for cyclic points
+inline bool Foam::pointData::sameGeometry
+(
+    const pointData& w2,
+    const scalar tol
+) const
+{
+    scalar diff = Foam::mag(distSqr() - w2.distSqr());
+
+    if (diff < SMALL)
+    {
+        return true;
+    }
+    else
+    {
+        if ((distSqr() > SMALL) && ((diff/distSqr()) < tol))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+
+inline void Foam::pointData::leaveDomain
+(
+    const polyPatch& patch,
+    const label patchPointI,
+    const point& coord
+)
+{
+    origin_ -= coord;
+}
+
+
+inline void Foam::pointData::transform(const tensor& rotTensor)
+{
+    origin_ = Foam::transform(rotTensor, origin_);
+}
+
+
+// Update absolute geometric quantities. Note that distance (distSqr_)
+// is not affected by leaving/entering domain.
+inline void Foam::pointData::enterDomain
+(
+    const polyPatch& patch,
+    const label patchPointI,
+    const point& coord
+)
+{
+    // back to absolute form
+    origin_ += coord;
+}
+
+
+// Update this with information from connected edge
+inline bool Foam::pointData::updatePoint
+(
+    const polyMesh& mesh,
+    const label pointI,
+    const label edgeI,
+    const pointData& edgeInfo,
+    const scalar tol
+)
+{
+    return 
+        update
+        (
+            mesh.points()[pointI],
+            edgeInfo,
+            tol
+        );
+    }    
+
+
+// Update this with new information on same point
+inline bool Foam::pointData::updatePoint
+(
+    const polyMesh& mesh,
+    const label pointI,
+    const pointData& newPointInfo,
+    const scalar tol
+)
+{
+    return
+        update
+        (
+            mesh.points()[pointI],
+            newPointInfo,
+            tol
+        );
+}    
+
+
+// Update this with new information on same point. No extra information.
+inline bool Foam::pointData::updatePoint
+(
+    const pointData& newPointInfo,
+    const scalar tol
+)
+{
+    return update(newPointInfo, tol);
+}    
+
+
+// Update this with information from connected point
+inline bool Foam::pointData::updateEdge
+(
+    const polyMesh& mesh,
+    const label edgeI,
+    const label pointI,
+    const pointData& pointInfo,
+    const scalar tol
+)
+{
+    const pointField& points = mesh.points();
+
+    const edge& e = mesh.edges()[edgeI];
+
+    const point edgeMid(0.5*(points[e[0]] + points[e[1]]));
+
+    return
+        update
+        (
+            edgeMid,
+            pointInfo,
+            tol
+        );
+}    
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline bool Foam::pointData::operator==(const pointData& rhs) const
+{
+    return origin() == rhs.origin();
+}
+
+
+inline bool Foam::pointData::operator!=(const pointData& rhs) const
+{
+    return !(*this == rhs);
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
new file mode 100644
index 0000000000..ffac7a5e8d
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -0,0 +1,2011 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    meshRefinement
+
+\*----------------------------------------------------------------------------*/
+
+#include "Pstream.H"
+#include "meshRefinement.H"
+
+#include "volMesh.H"
+#include "volFields.H"
+#include "surfaceMesh.H"
+#include "syncTools.H"
+#include "Time.H"
+#include "refinementHistory.H"
+#include "refinementSurfaces.H"
+#include "cellSet.H"
+#include "decompositionMethod.H"
+#include "regionSplit.H"
+#include "fvMeshDistribute.H"
+#include "indirectPrimitivePatch.H"
+#include "polyTopoChange.H"
+#include "removeCells.H"
+#include "mapDistributePolyMesh.H"
+#include "localPointRegion.H"
+#include "pointMesh.H"
+#include "pointFields.H"
+#include "slipPointPatchFields.H"
+#include "fixedValuePointPatchFields.H"
+#include "globalPointPatchFields.H"
+#include "calculatedPointPatchFields.H"
+#include "processorPointPatch.H"
+#include "featureEdgeMesh.H"
+#include "globalIndex.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(meshRefinement, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::meshRefinement::calcNeighbourData
+(
+    labelList& neiLevel,
+    pointField& neiCc
+)  const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    label nBoundaryFaces = mesh_.nFaces() - mesh_.nInternalFaces();
+
+    if (neiLevel.size() != nBoundaryFaces || neiCc.size() != nBoundaryFaces)
+    {
+        FatalErrorIn("meshRefinement::calcNeighbour(..)") << "nBoundaries:"
+            << nBoundaryFaces << " neiLevel:" << neiLevel.size()
+            << abort(FatalError);
+    }
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        const unallocLabelList& faceCells = pp.faceCells();
+        const vectorField::subField faceCentres = pp.faceCentres();
+
+        label bFaceI = pp.start()-mesh_.nInternalFaces();
+
+        if (pp.coupled())
+        {
+            forAll(faceCells, i)
+            {
+                neiLevel[bFaceI] = cellLevel[faceCells[i]];
+                neiCc[bFaceI] = cellCentres[faceCells[i]];
+                bFaceI++;
+            }
+        }
+        else
+        {
+            forAll(faceCells, i)
+            {
+                neiLevel[bFaceI] = cellLevel[faceCells[i]];
+                neiCc[bFaceI] = faceCentres[i];
+                bFaceI++;
+            }
+        }
+    }
+
+    // Swap coupled boundaries. Apply separation to cc since is coordinate.
+    syncTools::swapBoundaryFaceList(mesh_, neiCc, true);
+    syncTools::swapBoundaryFaceList(mesh_, neiLevel, false);
+}
+
+
+//void Foam::meshRefinement::calcCanonicalBoundaryData
+//(
+//    labelList& leftLevel,
+//    pointField& leftCc,
+//    labelList& rightLevel,
+//    pointField& rightCc
+//)  const
+//{
+//    const labelList& cellLevel = meshCutter_.cellLevel();
+//    const pointField& cellCentres = mesh_.cellCentres();
+//    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+//
+//    // Get boundary face centre and level. Coupled aware.
+//    calcNeighbourData(rightLevel, rightCc);
+//
+//    // Get owner face centre and level. Canonical sort for coupled faces.
+//    forAll(patches, patchI)
+//    {
+//        const polyPatch& pp = patches[patchI];
+//
+//        const unallocLabelList& faceCells = pp.faceCells();
+//        const vectorField::subField faceCentres = pp.faceCentres();
+//
+//        if (isA<processorPolyPatch>(pp))
+//        {
+//            const processorPolyPatch& procPp =
+//                refCast<const processorPolyPatch>(patches[patchI]);
+//
+//            label bFaceI = pp.start()-mesh_.nInternalFaces();
+//            forAll(faceCells, i)
+//            {
+//                leftLevel[bFaceI] = cellLevel[faceCells[i]];
+//                leftCc[bFaceI] = cellCentres[faceCells[i]];
+//                bFaceI++;
+//            }
+//
+//            // Swap if on neighbour so both sides have same values
+//            if (!procPp.owner())
+//            {
+//                forAll(leftLevel, i)
+//                {
+//                    Swap(leftLevel[i], rightLevel[i]);
+//                    Swap(leftCc[i], rightCc[i]);
+//                }
+//            }
+//        }
+//        else if (isA<cyclicPolyPatch>(pp))
+//        {
+//            const processorPolyPatch& cycPp =
+//                refCast<const processorPolyPatch>(patches[patchI]);
+//
+//            label bFaceI = pp.start()-mesh_.nInternalFaces();
+//            forAll(faceCells, i)
+//            {
+//                leftLevel[bFaceI] = cellLevel[faceCells[i]];
+//                leftCc[bFaceI] = cellCentres[faceCells[i]];
+//                bFaceI++;
+//            }
+//
+//            // First half has data in normal order: owner in leftLevel,leftCc
+//            // and coupled data in rightLevel, rightCc. Second half has it
+//            // swapped:
+//            bFaceI = pp.start()+cycPp.size()/2-mesh_.nInternalFaces();
+//            for (label i = 0; i < cycPp.size()/2; i++)
+//            {
+//                Swap(leftLevel[bFaceI], rightLevel[bFaceI]);
+//                Swap(leftCc[bFaceI], rightCc[bFaceI]);
+//                bFaceI++;
+//            }
+//        }
+//        else
+//        {
+//            label bFaceI = pp.start()-mesh_.nInternalFaces();
+//            forAll(faceCells, i)
+//            {
+//                leftLevel[bFaceI] = cellLevel[faceCells[i]];
+//                leftCc[bFaceI] = cellCentres[faceCells[i]];
+//                bFaceI++;
+//            }
+//        }
+//    }
+//}
+
+
+// Find intersections of edges (given by their two endpoints) with surfaces.
+// Returns first intersection if there are more than one.
+void Foam::meshRefinement::updateIntersections(const labelList& changedFaces)
+{
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    label nTotEdges = returnReduce(surfaceIndex_.size(), sumOp<label>());
+    label nChangedFaces = returnReduce(changedFaces.size(), sumOp<label>());
+
+    Info<< "Edge intersection testing:" << nl
+        << "    Number of edges             : " << nTotEdges << nl
+        << "    Number of edges to retest   : " << nChangedFaces
+        << endl;
+
+    // Get boundary face centre and level. Coupled aware.
+    labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+    pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+    calcNeighbourData(neiLevel, neiCc);
+
+    forAll(changedFaces, i)
+    {
+        label faceI = changedFaces[i];
+        label own = mesh_.faceOwner()[faceI];
+
+        pointIndexHit surfaceHitInfo;
+
+        if (mesh_.isInternalFace(faceI))
+        {
+            surfaceIndex_[faceI] = surfaces_.findAnyIntersection
+            (
+                cellCentres[own],
+                cellCentres[mesh_.faceNeighbour()[faceI]],
+                surfaceHitInfo
+            );
+        }
+        else
+        {
+            surfaceIndex_[faceI] = surfaces_.findAnyIntersection
+            (
+                cellCentres[own],
+                neiCc[faceI-mesh_.nInternalFaces()],
+                surfaceHitInfo
+            );
+        }
+    }
+
+    // Make sure both sides have same information. This should be
+    // case in general since same vectors but just to make sure.
+    syncTools::syncFaceList(mesh_, surfaceIndex_, maxEqOp<label>(), false);
+
+    label nHits = countHits();
+    label nTotHits = returnReduce(nHits, sumOp<label>());
+
+    Info<< "    Number of intersected edges : " << nTotHits << endl;
+
+    // Set files to same time as mesh
+    setInstance(mesh_.facesInstance());
+}
+
+
+void Foam::meshRefinement::checkData()
+{
+    Pout<< "meshRefinement::checkData() : Checking refinement structure."
+        << endl;
+    meshCutter_.checkMesh();
+
+    Pout<< "meshRefinement::checkData() : Checking refinement levels."
+        << endl;
+    meshCutter_.checkRefinementLevels(1, labelList(0));
+
+
+    Pout<< "meshRefinement::checkData() : Checking synchronization."
+        << endl;
+
+    // Check face centres
+    {
+        // Boundary face centres
+        pointField::subList boundaryFc
+        (
+            mesh_.faceCentres(),
+            mesh_.nFaces()-mesh_.nInternalFaces(),
+            mesh_.nInternalFaces()
+        );
+
+        // Get neighbouring face centres
+        pointField neiBoundaryFc(boundaryFc);
+        syncTools::swapBoundaryFaceList
+        (
+            mesh_,
+            neiBoundaryFc,
+            true
+        );
+
+        // Compare
+        testSyncBoundaryFaceList
+        (
+            tol_,
+            "testing faceCentres : ",
+            boundaryFc,
+            neiBoundaryFc
+        );
+    }
+    // Check meshRefinement
+    {
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            label own = mesh_.faceOwner()[faceI];
+            label nei = mesh_.faceNeighbour()[faceI];
+            const point& ownCc = mesh_.cellCentres()[own];
+            const point& neiCc = mesh_.cellCentres()[nei];
+
+            pointIndexHit surfaceHitInfo;
+            label surfI = surfaces_.findAnyIntersection
+            (
+                ownCc,
+                neiCc,
+                surfaceHitInfo
+            );
+
+            if (surfI != surfaceIndex_[faceI])
+            {
+                WarningIn("meshRefinement::checkData()")
+                    << "Internal face:" << faceI
+                    << " fc:" << mesh_.faceCentres()[faceI]
+                    << " cached surfaceIndex_:" << surfaceIndex_[faceI]
+                    << " current:" << surfI
+                    << " ownCc:" << ownCc << " neiCc:" << neiCc
+                    << endl;
+            }
+        }
+
+        // Get boundary face centre and level. Coupled aware.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+        pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+        calcNeighbourData(neiLevel, neiCc);
+
+        for
+        (
+            label faceI = mesh_.nInternalFaces();
+            faceI < mesh_.nFaces();
+            faceI++
+        )
+        {
+            label own = mesh_.faceOwner()[faceI];
+            const point& ownCc = mesh_.cellCentres()[own];
+
+            pointIndexHit surfaceHitInfo;
+            label surfI = surfaces_.findAnyIntersection
+            (
+                ownCc,
+                neiCc[faceI-mesh_.nInternalFaces()],
+                surfaceHitInfo
+            );
+
+            if (surfI != surfaceIndex_[faceI])
+            {
+                WarningIn("meshRefinement::checkData()")
+                    << "Boundary face:" << faceI
+                    << " patch:" << mesh_.boundaryMesh().whichPatch(faceI)
+                    << " fc:" << mesh_.faceCentres()[faceI]
+                    << " cached surfaceIndex_:" << surfaceIndex_[faceI]
+                    << " current:" << surfI
+                    << " ownCc:" << ownCc
+                    << " neiCc:" << neiCc[faceI-mesh_.nInternalFaces()]
+                    << endl;
+            }
+        }
+    }
+    {
+        labelList::subList boundarySurface
+        (
+            surfaceIndex_,
+            mesh_.nFaces()-mesh_.nInternalFaces(),
+            mesh_.nInternalFaces()
+        );
+
+        labelList neiBoundarySurface(boundarySurface);
+        syncTools::swapBoundaryFaceList
+        (
+            mesh_,
+            neiBoundarySurface,
+            false
+        );
+
+        // Compare
+        testSyncBoundaryFaceList
+        (
+            0,                              // tolerance
+            "testing surfaceIndex() : ",
+            boundarySurface,
+            neiBoundarySurface
+        );
+    }
+
+
+    // Find duplicate faces
+    Pout<< "meshRefinement::checkData() : Counting duplicate faces."
+        << endl;
+
+    labelList duplicateFace
+    (
+        localPointRegion::findDuplicateFaces
+        (
+            mesh_,
+            identity(mesh_.nFaces()-mesh_.nInternalFaces())
+          + mesh_.nInternalFaces()
+        )
+    );
+
+    // Count
+    {
+        label nDup = 0;
+
+        forAll(duplicateFace, i)
+        {
+            if (duplicateFace[i] != -1)
+            {
+                nDup++;
+            }
+        }
+        nDup /= 2;  // will have counted both faces of duplicate
+        Pout<< "meshRefinement::checkData() : Found " << nDup
+            << " duplicate pairs of faces." << endl;
+    }
+}
+
+
+void Foam::meshRefinement::setInstance(const fileName& inst)
+{
+    meshCutter_.setInstance(inst);
+    surfaceIndex_.instance() = inst;
+}
+
+
+// Remove cells. Put exposedFaces (output of getExposedFaces(cellsToRemove))
+// into exposedPatchIDs.
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRemoveCells
+(
+    const labelList& cellsToRemove,
+    const labelList& exposedFaces,
+    const labelList& exposedPatchIDs,
+    removeCells& cellRemover
+)
+{
+    polyTopoChange meshMod(mesh_);
+
+    // Arbitrary: put exposed faces into last patch.
+    cellRemover.setRefinement
+    (
+        cellsToRemove,
+        exposedFaces,
+        exposedPatchIDs,
+        meshMod
+    );
+
+    // Change the mesh (no inflation)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh (since morphing might not do this)
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+    else
+    {
+        // Delete mesh volumes. No other way to do this?
+        mesh_.clearOut();
+    }
+
+    // Update local mesh data
+    cellRemover.updateMesh(map);
+
+    // Update intersections. Recalculate intersections for exposed faces.
+    labelList newExposedFaces = renumber
+    (
+        map().reverseFaceMap(),
+        exposedFaces
+    );
+
+    //Pout<< "removeCells : updating intersections for "
+    //    << newExposedFaces.size() << " newly exposed faces." << endl;
+
+    updateMesh(map, newExposedFaces);
+
+    return map;
+}
+
+
+// Get which are inside any closed surface. Note that all closed surfaces
+// will have already been oriented to have keepPoint outside.
+Foam::labelList Foam::meshRefinement::getInsideCells
+(
+    const word& postfix
+) const
+{
+    const pointField& points = mesh_.points();
+
+    // This test can be done in various ways. The ultimate is the intersection
+    // of any edge of the mesh with any surface and intersection of any edge
+    // of any surface of the mesh with any mesh face.
+    // For now:
+    // - none of the edges of a cell intersects any surface
+    // - any point of the cell is inside.
+
+
+    // Is point inside any closed surface?
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    PackedList<1> pointIsInside;
+    label nPointInside = surfaces_.markInsidePoints
+    (
+       points,
+       pointIsInside
+    );
+
+    if (debug)
+    {
+        Pout<< "getInsideCells : Points internal to closed surfaces :"
+            << " local:" << nPointInside
+            << " global:" << returnReduce(nPointInside, sumOp<label>())
+            << endl;
+    }
+
+
+    // Find cells with all points inside closed surface
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    PackedList<1> cellIsInside(mesh_.nCells(), 1u);
+    label nCellInside = mesh_.nCells();
+
+    // Unmark cells with any point outside
+    forAll(points, pointI)
+    {
+        if (pointIsInside.get(pointI) == 0u)
+        {
+            // Outside point. Unmark cells.
+            const labelList& pCells = mesh_.pointCells()[pointI];
+
+            forAll(pCells, i)
+            {
+                label cellI = pCells[i];
+
+                if (cellIsInside.get(cellI) == 1u)
+                {
+                    cellIsInside.set(cellI, 0u);
+                    nCellInside--;
+                }
+            }
+        }
+    }
+
+    label totNCellInside = nCellInside;
+    reduce(totNCellInside, sumOp<label>());
+    if (debug)
+    {
+        Pout<< "getInsideCells : Cells using inside points only :"
+            << " local:" << nCellInside << " global:" << totNCellInside
+            << endl;
+    }
+
+    // Filter any cells with cc-cc edge intersection
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const cellList& cells = mesh_.cells();
+
+    cellSet insidePoints(mesh_, "insidePoints_"+postfix, mesh_.nCells()/100);
+    cellSet insidePointsButCut
+    (
+        mesh_,
+        "insidePointsButCut_"+postfix,
+        mesh_.nCells()/100
+    );
+
+    forAll(cells, cellI)
+    {
+        if (cellIsInside.get(cellI) == 1u)
+        {
+            insidePoints.insert(cellI);
+
+            const cell& cFaces = cells[cellI];
+
+            forAll(cFaces, i)
+            {
+                if (surfaceIndex_[cFaces[i]] != -1)
+                {
+                    cellIsInside.set(cellI, 0u);
+                    nCellInside--;
+
+                    insidePointsButCut.insert(cellI);
+
+                    break;
+                }
+            }
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "getInsideCells : cells with all points inside : "
+            << insidePoints.objectPath() << endl;
+        insidePoints.write();
+        Pout<< "getInsideCells : cells with all points inside"
+            << " but intersecting (cc) surface : "
+            << insidePointsButCut.objectPath() << endl;
+        insidePointsButCut.write();
+    }
+
+    totNCellInside = nCellInside;
+    reduce(totNCellInside, sumOp<label>());
+    if (debug)
+    {
+        Pout<< "getInsideCells : After filtering cc-cc intersections :"
+            << " local:" << nCellInside << " global:" << totNCellInside
+            << endl;
+    }
+
+
+    // Filter cells with any normal edge intersection
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    cellSet insidePointsButEdge
+    (
+        mesh_,
+        "insidePointsButEdge_"+postfix,
+        mesh_.nCells()/100
+    );
+
+    const labelListList& edgeCells = mesh_.edgeCells();
+
+    forAll(edgeCells, edgeI)
+    {
+        const labelList& eCells = edgeCells[edgeI];
+
+        // Does edge use any inside cells? Prefilter since edge intersection
+        // test expensive.
+        bool edgeHasInsideCells = false;
+
+        forAll(eCells, i)
+        {
+            if (cellIsInside.get(eCells[i]) == 1u)
+            {
+                edgeHasInsideCells = true;
+                break;
+            }
+        }
+
+        if (edgeHasInsideCells)
+        {
+            const edge& e = mesh_.edges()[edgeI];
+
+            // Find any pierces of surface by mesh edge.
+            pointIndexHit hit;
+            label surfI = surfaces().findHigherIntersection
+            (
+                points[e[0]],
+                points[e[1]],
+                -1,                     // minimum level.
+                hit
+            );
+
+            if (surfI != -1)
+            {
+                // This edge intersects some surface. Unmark all cells
+                // using this edge.
+
+                forAll(eCells, i)
+                {
+                    if (cellIsInside.get(eCells[i]) == 1u)
+                    {
+                        cellIsInside.set(eCells[i], 0u);
+                        nCellInside--;
+
+                        insidePointsButEdge.insert(eCells[i]);
+                    }
+                }
+            }
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "getInsideCells : cells with all points inside"
+            << " but intersecting (edges) surface : "
+            << insidePointsButEdge.objectPath() << endl;
+        insidePointsButEdge.write();
+    }
+
+    totNCellInside = nCellInside;
+    reduce(totNCellInside, sumOp<label>());
+    if (debug)
+    {
+        Pout<< "getInsideCells : After filtering edge interesections :"
+            << " local:" << nCellInside << " global:" << totNCellInside
+            << endl;
+    }
+
+
+    // Collect cells
+    // ~~~~~~~~~~~~~
+
+    DynamicList<label> cellsToRemove(nCellInside);
+
+    forAll(cellIsInside, cellI)
+    {
+        if (cellIsInside.get(cellI) == 1u)
+        {
+            cellsToRemove.append(cellI);
+        }
+    }
+    return cellsToRemove.shrink();
+}
+
+
+// Do all to remove inside cells
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::removeInsideCells
+(
+    const string& msg,
+    const label exposedPatchI
+)
+{
+    labelList insideCells
+    (
+        getInsideCells
+        (
+            string::validate<word>(msg)
+        )
+    );
+
+    Info<< "Removing inside cells : "
+        << returnReduce(insideCells.size(), sumOp<label>())
+        << '.' << endl;
+
+    removeCells cellRemover(mesh_);
+
+    labelList exposedFaces(cellRemover.getExposedFaces(insideCells));
+
+    // Debug check
+    forAll(exposedFaces, i)
+    {
+        label faceI = exposedFaces[i];
+
+        if (surfaceIndex_[faceI] != -1)
+        {
+            FatalErrorIn
+            (
+                "removeInsideCells"
+                "(const label, const string&, const label)"
+            )   << "Face:" << faceI
+                << " fc:" << mesh_.faceCentres()[faceI]
+                << " is actually cutting the surface and should never have been"
+                << " included in the cells to remove."
+                << abort(FatalError);
+        }
+    }
+
+    return doRemoveCells
+    (
+        insideCells,
+        exposedFaces,
+        labelList(exposedFaces.size(), exposedPatchI),
+        cellRemover
+    );
+}
+
+
+// Determine for multi-processor regions the lowest numbered cell on the lowest
+// numbered processor.
+void Foam::meshRefinement::getRegionMaster
+(
+    const boolList& blockedFace,
+    const regionSplit& globalRegion,
+    Map<label>& regionToMaster
+) const
+{
+    globalIndex globalCells(mesh_.nCells());
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (isA<processorPolyPatch>(pp))
+        {
+            forAll(pp, i)
+            {
+                label faceI = pp.start()+i;
+
+                if (!blockedFace[faceI])
+                {
+                    // Only if there is a connection to the neighbour
+                    // will there be a multi-domain region; if not through
+                    // this face then through another.
+
+                    label cellI = mesh_.faceOwner()[faceI];
+                    label globalCellI = globalCells.toGlobal(cellI);
+
+                    Map<label>::iterator iter =
+                        regionToMaster.find(globalRegion[cellI]);
+
+                    if (iter != regionToMaster.end())
+                    {
+                        label master = iter();
+                        iter() = min(master, globalCellI);
+                    }
+                    else
+                    {
+                        regionToMaster.insert
+                        (
+                            globalRegion[cellI],
+                            globalCellI
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    // Do reduction
+    Pstream::mapCombineGather(regionToMaster, minEqOp<label>());
+    Pstream::mapCombineScatter(regionToMaster);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+Foam::meshRefinement::meshRefinement
+(
+    fvMesh& mesh,
+    const scalar tol,
+    const refinementSurfaces& surfaces
+)
+:
+    mesh_(mesh),
+    tol_(tol),
+    surfaces_(surfaces),
+    meshCutter_
+    (
+        mesh,
+        labelIOList
+        (
+            IOobject
+            (
+                "cellLevel",
+                mesh_.facesInstance(),
+                fvMesh::meshSubDir,
+                mesh,
+                IOobject::READ_IF_PRESENT,
+                IOobject::NO_WRITE,
+                false
+            ),
+            labelList(mesh_.nCells(), 0)
+        ),
+        labelIOList
+        (
+            IOobject
+            (
+                "pointLevel",
+                mesh_.facesInstance(),
+                fvMesh::meshSubDir,
+                mesh,
+                IOobject::READ_IF_PRESENT,
+                IOobject::NO_WRITE,
+                false
+            ),
+            labelList(mesh_.nPoints(), 0)
+        ),
+        refinementHistory
+        (
+            IOobject
+            (
+                "refinementHistory",
+                mesh_.facesInstance(),
+                fvMesh::meshSubDir,
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            List<refinementHistory::splitCell8>(0),
+            labelList(0)
+        )   // no unrefinement
+    ),
+    surfaceIndex_
+    (
+        IOobject
+        (
+            "surfaceIndex",
+            mesh_.facesInstance(),
+            fvMesh::meshSubDir,
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        labelList(mesh_.nFaces(), -1)
+    ),
+    userFaceData_(0)
+{
+    // recalculate intersections for all faces
+    updateIntersections(identity(mesh_.nFaces()));
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::meshRefinement::countHits() const
+{
+    label nHits = 0;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] >= 0)
+        {
+            nHits++;
+        }
+    }
+    return nHits;
+}
+
+
+//// Determine distribution to keep baffles together
+//Foam::labelList Foam::meshRefinement::decomposePreserveBaffles
+//(
+//    decompositionMethod& decomposer
+//) const
+//{
+//    // Find duplicate faces
+//    labelList duplicateFace
+//    (
+//        localPointRegion::findDuplicateFaces
+//        (
+//            mesh_,
+//            identity(mesh_.nFaces()-mesh_.nInternalFaces())
+//          + mesh_.nInternalFaces()
+//        )
+//    );
+//
+//
+//    // Agglomerate cells on both sides of duplicate face pair
+//
+//    const pointField& cellCentres = mesh_.cellCentres();
+//    const labelList& faceOwner = mesh_.faceOwner();
+//
+//    labelList toAgglom(mesh_.nCells(), -1);
+//    pointField agglomCellCentres(mesh_.nCells());
+//    labelList nAgglomCellCentres(mesh_.nCells(), 0);
+//
+//    label agglomI = 0;
+//
+//    // Do all baffle cells
+//    forAll(duplicateFace, i)
+//    {
+//        if (duplicateFace[i] != -1)
+//        {
+//            label own = faceOwner[i+mesh_.nInternalFaces()];
+//            label otherOwn =
+//                faceOwner[duplicateFace[i]+mesh_.nInternalFaces()];
+//
+//            if (toAgglom[own] == -1 && toAgglom[otherOwn] == -1)
+//            {
+//                // Allocate new agglomeration
+//                agglomCellCentres[agglomI] =
+//                    cellCentres[own]
+//                  + cellCentres[otherOwn];
+//                nAgglomCellCentres[agglomI] = 2;
+//                toAgglom[own] = agglomI;
+//                toAgglom[otherOwn] = agglomI;
+//                agglomI++;
+//            }
+//            else if (toAgglom[own] != -1)
+//            {
+//                // Owner already part of agglomeration. Add otherOwn to it.
+//                label destAgglom = toAgglom[own];
+//                agglomCellCentres[destAgglom] += cellCentres[otherOwn];
+//                nAgglomCellCentres[destAgglom]++;
+//                toAgglom[otherOwn] = destAgglom;
+//            }
+//            else if (toAgglom[otherOwn] != -1)
+//            {
+//                // otherOwn already part of agglomeration. Add own to it.
+//                label destAgglom = toAgglom[otherOwn];
+//                agglomCellCentres[destAgglom] += cellCentres[own];
+//                nAgglomCellCentres[destAgglom]++;
+//                toAgglom[own] = destAgglom;
+//            }
+//        }
+//    }
+//
+//    // Do all other cells
+//    forAll(toAgglom, cellI)
+//    {
+//        if (toAgglom[cellI] == -1)
+//        {
+//            agglomCellCentres[agglomI] = cellCentres[cellI];
+//            nAgglomCellCentres[agglomI] = 1;
+//            toAgglom[cellI] = agglomI;
+//            agglomI++;
+//        }
+//    }
+//
+//    // Average
+//    agglomCellCentres.setSize(agglomI);
+//
+//    forAll(agglomCellCentres, i)
+//    {
+//        agglomCellCentres[i] /= nAgglomCellCentres[i];
+//    }
+//
+//    // Decompose based on agglomerated cell centres
+//    labelList agglomDistribution(decomposer.decompose(agglomCellCentres));
+//
+//    // Rework back into decomposition for original mesh_
+//    labelList distribution(mesh_.nCells());
+//
+//    forAll(toAgglom, cellI)
+//    {
+//        distribution[cellI] = agglomDistribution[toAgglom[cellI]];
+//    }
+//
+//    return distribution;
+//}
+
+
+// Determine distribution to move connected regions onto one processor.
+Foam::labelList Foam::meshRefinement::decomposeCombineRegions
+(
+    const boolList& blockedFace,
+    const List<labelPair>& explicitConnections,
+    decompositionMethod& decomposer
+) const
+{
+    // Determine global regions, separated by blockedFaces
+    regionSplit globalRegion(mesh_, blockedFace, explicitConnections);
+
+    // Now globalRegion has global region per cell. Problem is that
+    // the region might span multiple domains so we want to get
+    // a "region master" per domain. Note that multi-processor
+    // regions can only occur on cells on coupled patches.
+
+
+    // Determine per coupled region the master cell (lowest numbered cell
+    // on lowest numbered processor)
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Map<label> regionToMaster(mesh_.nFaces()-mesh_.nInternalFaces());
+    getRegionMaster(blockedFace, globalRegion, regionToMaster);
+
+
+    // Global cell numbering engine
+    globalIndex globalCells(mesh_.nCells());
+
+
+    // Determine cell centre per region
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Now we can divide regions into
+    // - single-processor regions (almost all)
+    //   - allocate local region + coordinate for it
+    // - multi-processor for which I am master
+    //   - allocate local region + coordinate for it
+    // - multi-processor for which I am not master
+    //   - do not allocate region.
+    //   - but inherit new distribution from master.
+
+    Map<label> globalToLocalRegion(mesh_.nCells());
+    DynamicList<point> localCc(mesh_.nCells()/10);
+
+    forAll(globalRegion, cellI)
+    {
+        Map<label>::const_iterator fndMaster =
+            regionToMaster.find(globalRegion[cellI]);
+
+        if (fndMaster != regionToMaster.end())
+        {
+            // Multi-processor region.
+            if (globalCells.toGlobal(cellI) == fndMaster())
+            {
+                // I am master. Allocate region for me.
+                globalToLocalRegion.insert(globalRegion[cellI], localCc.size());
+                localCc.append(mesh_.cellCentres()[cellI]);
+            }
+        }
+        else
+        {
+            // Single processor region.
+            Map<label>::iterator iter =
+                globalToLocalRegion.find(globalRegion[cellI]);
+
+            if (iter == globalToLocalRegion.end())
+            {
+                globalToLocalRegion.insert(globalRegion[cellI], localCc.size());
+                localCc.append(mesh_.cellCentres()[cellI]);
+            }
+        }
+    }
+    localCc.shrink();
+    pointField localPoints;
+    localPoints.transfer(localCc);
+
+
+    // Call decomposer on localCc
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList localDistribution = decomposer.decompose(localPoints);
+
+
+    // Distribute the destination processor for coupled regions
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Map<label> regionToDist(regionToMaster.size());
+
+    forAllConstIter(Map<label>, regionToMaster, iter)
+    {
+        if (globalCells.isLocal(iter()))
+        {
+            // Master cell is local.
+            regionToDist.insert
+            (
+                iter.key(),
+                localDistribution[globalToLocalRegion[iter.key()]]
+            );
+        }
+        else
+        {
+            // Master cell is not on this processor. Make sure it is overridden.
+            regionToDist.insert(iter.key(), labelMax);
+        }
+    }
+    Pstream::mapCombineGather(regionToDist, minEqOp<label>());
+    Pstream::mapCombineScatter(regionToDist);
+
+
+    // Convert region-based decomposition back to cell-based one
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList distribution(mesh_.nCells());
+
+    forAll(globalRegion, cellI)
+    {
+        Map<label>::const_iterator fndMaster =
+            regionToDist.find(globalRegion[cellI]);
+
+        if (fndMaster != regionToDist.end())
+        {
+            // Special handling
+            distribution[cellI] = fndMaster();
+        }
+        else
+        {
+            // region is local to the processor.
+            label localRegionI = globalToLocalRegion[globalRegion[cellI]];
+
+            distribution[cellI] = localDistribution[localRegionI];
+        }
+    }
+    return distribution;
+}
+
+
+// Helper function to get intersected faces
+Foam::labelList Foam::meshRefinement::intersectedFaces() const
+{
+    // Mark all faces that will become baffles
+
+    label nBoundaryFaces = 0;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            nBoundaryFaces++;
+        }
+    }
+
+    labelList surfaceFaces(nBoundaryFaces);
+    nBoundaryFaces = 0;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            surfaceFaces[nBoundaryFaces++] = faceI;
+        }
+    }
+    return surfaceFaces;
+}
+
+
+// Helper function to get points used by faces
+Foam::labelList Foam::meshRefinement::intersectedPoints
+(
+//    const labelList& globalToPatch
+) const
+{
+    const faceList& faces = mesh_.faces();
+
+    // Mark all points on faces that will become baffles
+    PackedList<1> isBoundaryPoint(mesh_.nPoints(), 0u);
+    label nBoundaryPoints = 0;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            const face& f = faces[faceI];
+
+            forAll(f, fp)
+            {
+                if (isBoundaryPoint.get(f[fp]) == 0u)
+                {
+                    isBoundaryPoint.set(f[fp], 1u);
+                    nBoundaryPoints++;
+                }
+            }
+        }
+    }
+
+    //// Insert all meshed patches.
+    //forAll(globalToPatch, i)
+    //{
+    //    label patchI = globalToPatch[i];
+    //
+    //    if (patchI != -1)
+    //    {
+    //        const polyPatch& pp = mesh_.boundaryMesh()[patchI];
+    //
+    //        label faceI = pp.start();
+    //
+    //        forAll(pp, i)
+    //        {
+    //            const face& f = faces[faceI];
+    //
+    //            forAll(f, fp)
+    //            {
+    //                if (isBoundaryPoint.get(f[fp]) == 0u)
+    //                {
+    //                    isBoundaryPoint.set(f[fp], 1u);
+    //                    nBoundaryPoints++;
+    //                }
+    //            }
+    //            faceI++;
+    //        }
+    //    }
+    //}
+
+
+    // Pack
+    labelList boundaryPoints(nBoundaryPoints);
+    nBoundaryPoints = 0;
+    forAll(isBoundaryPoint, pointI)
+    {
+        if (isBoundaryPoint.get(pointI) == 1u)
+        {
+            boundaryPoints[nBoundaryPoints++] = pointI;
+        }
+    }
+
+    return boundaryPoints;
+}
+
+
+Foam::labelList Foam::meshRefinement::addedPatches
+(
+    const labelList& globalToPatch
+)
+{
+    labelList patchIDs(globalToPatch.size());
+    label addedI = 0;
+
+    forAll(globalToPatch, i)
+    {
+        if (globalToPatch[i] != -1)
+        {
+            patchIDs[addedI++] = globalToPatch[i];
+        }
+    }
+    patchIDs.setSize(addedI);
+
+    return patchIDs;
+}
+
+
+//- Create patch from set of patches
+Foam::autoPtr<Foam::indirectPrimitivePatch> Foam::meshRefinement::makePatch
+(
+    const polyMesh& mesh,
+    const labelList& patchIDs
+)
+{
+    const polyBoundaryMesh& patches = mesh.boundaryMesh();
+
+    // Count faces.
+    label nFaces = 0;
+
+    forAll(patchIDs, i)
+    {
+        const polyPatch& pp = patches[patchIDs[i]];
+
+        nFaces += pp.size();
+    }
+
+    // Collect faces.
+    labelList addressing(nFaces);
+    nFaces = 0;
+
+    forAll(patchIDs, i)
+    {
+        const polyPatch& pp = patches[patchIDs[i]];
+
+        label meshFaceI = pp.start();
+
+        forAll(pp, i)
+        {
+            addressing[nFaces++] = meshFaceI++;
+        }
+    }
+
+    return autoPtr<indirectPrimitivePatch>
+    (
+        new indirectPrimitivePatch
+        (
+            IndirectList<face>(mesh.faces(), addressing),
+            mesh.points()
+        )
+    );
+}
+
+
+// Construct pointVectorField with correct boundary conditions
+Foam::tmp<Foam::pointVectorField> Foam::meshRefinement::makeDisplacementField
+(
+    const pointMesh& pMesh,
+    const labelList& adaptPatchIDs
+)
+{
+    const polyMesh& mesh = pMesh();
+
+    // Construct displacement field.
+    const pointBoundaryMesh& pointPatches = pMesh.boundary();
+
+    wordList patchFieldTypes
+    (
+        pointPatches.size(),
+        slipPointPatchVectorField::typeName
+    );
+
+    forAll(adaptPatchIDs, i)
+    {
+        patchFieldTypes[adaptPatchIDs[i]] =
+            fixedValuePointPatchVectorField::typeName;
+    }
+
+    forAll(pointPatches, patchI)
+    {
+        if (isA<globalPointPatch>(pointPatches[patchI]))
+        {
+            patchFieldTypes[patchI] = globalPointPatchVectorField::typeName;
+        }
+        else if (isA<processorPointPatch>(pointPatches[patchI]))
+        {
+            patchFieldTypes[patchI] = calculatedPointPatchVectorField::typeName;
+        }
+    }
+
+    tmp<pointVectorField> tfld
+    (
+        new pointVectorField
+        (
+            IOobject
+            (
+                "pointDisplacement",
+                mesh.time().timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            pMesh,
+            dimensionedVector("displacement", dimLength, vector::zero),
+            patchFieldTypes
+        )
+    );
+    return tfld;
+}
+
+
+// Adds patch if not yet there. Returns patchID.
+Foam::label Foam::meshRefinement::addPatch
+(
+    fvMesh& mesh,
+    const word& patchName,
+    const word& patchType
+)
+{
+    polyBoundaryMesh& polyPatches =
+        const_cast<polyBoundaryMesh&>(mesh.boundaryMesh());
+
+    label patchI = polyPatches.findPatchID(patchName);
+    if (patchI != -1)
+    {
+        if (polyPatches[patchI].type() == patchType)
+        {
+            // Already there
+            return patchI;
+        }
+        //else
+        //{
+        //    FatalErrorIn
+        //    (
+        //        "meshRefinement::addPatch(fvMesh&, const word&, const word&)"
+        //    )   << "Patch " << patchName << " already exists but with type "
+        //        << patchType << nl
+        //        << "Current patch names:" << polyPatches.names()
+        //        << exit(FatalError);
+        //}
+    }
+
+
+    label insertPatchI = polyPatches.size();
+    label startFaceI = mesh.nFaces();
+
+    forAll(polyPatches, patchI)
+    {
+        const polyPatch& pp = polyPatches[patchI];
+
+        if (isA<processorPolyPatch>(pp))
+        {
+            insertPatchI = patchI;
+            startFaceI = pp.start();
+            break;
+        }
+    }
+
+
+    // Below is all quite a hack. Feel free to change once there is a better
+    // mechanism to insert and reorder patches.
+
+    // Clear local fields and e.g. polyMesh parallelInfo.
+    mesh.clearOut();
+
+    label sz = polyPatches.size();
+
+    fvBoundaryMesh& fvPatches = const_cast<fvBoundaryMesh&>(mesh.boundary());
+
+    // Add polyPatch at the end
+    polyPatches.setSize(sz+1);
+    polyPatches.set
+    (
+        sz,
+        polyPatch::New
+        (
+            patchType,
+            patchName,
+            0,              // size
+            startFaceI,
+            insertPatchI,
+            polyPatches
+        )
+    );
+    fvPatches.setSize(sz+1);
+    fvPatches.set
+    (
+        sz,
+        fvPatch::New
+        (
+            polyPatches[sz],  // point to newly added polyPatch
+            mesh.boundary()
+        )
+    );
+
+    addPatchFields<volScalarField>
+    (
+        mesh,
+        calculatedFvPatchField<scalar>::typeName
+    );
+    addPatchFields<volVectorField>
+    (
+        mesh,
+        calculatedFvPatchField<vector>::typeName
+    );
+    addPatchFields<volSphericalTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<sphericalTensor>::typeName
+    );
+    addPatchFields<volSymmTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<symmTensor>::typeName
+    );
+    addPatchFields<volTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<tensor>::typeName
+    );
+
+    // Surface fields
+
+    addPatchFields<surfaceScalarField>
+    (
+        mesh,
+        calculatedFvPatchField<scalar>::typeName
+    );
+    addPatchFields<surfaceVectorField>
+    (
+        mesh,
+        calculatedFvPatchField<vector>::typeName
+    );
+    addPatchFields<surfaceSphericalTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<sphericalTensor>::typeName
+    );
+    addPatchFields<surfaceSymmTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<symmTensor>::typeName
+    );
+    addPatchFields<surfaceTensorField>
+    (
+        mesh,
+        calculatedFvPatchField<tensor>::typeName
+    );
+
+    // Create reordering list
+    // patches before insert position stay as is
+    labelList oldToNew(sz+1);
+    for (label i = 0; i < insertPatchI; i++)
+    {
+        oldToNew[i] = i;
+    }
+    // patches after insert position move one up
+    for (label i = insertPatchI; i < sz; i++)
+    {
+        oldToNew[i] = i+1;
+    }
+    // appended patch gets moved to insert position
+    oldToNew[sz] = insertPatchI;
+
+    // Shuffle into place
+    polyPatches.reorder(oldToNew);
+    fvPatches.reorder(oldToNew);
+
+    reorderPatchFields<volScalarField>(mesh, oldToNew);
+    reorderPatchFields<volVectorField>(mesh, oldToNew);
+    reorderPatchFields<volSphericalTensorField>(mesh, oldToNew);
+    reorderPatchFields<volSymmTensorField>(mesh, oldToNew);
+    reorderPatchFields<volTensorField>(mesh, oldToNew);
+    reorderPatchFields<surfaceScalarField>(mesh, oldToNew);
+    reorderPatchFields<surfaceVectorField>(mesh, oldToNew);
+    reorderPatchFields<surfaceSphericalTensorField>(mesh, oldToNew);
+    reorderPatchFields<surfaceSymmTensorField>(mesh, oldToNew);
+    reorderPatchFields<surfaceTensorField>(mesh, oldToNew);
+
+    return insertPatchI;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMeshRegions
+(
+    const point& keepPoint
+)
+{
+    // Determine connected regions. regionSplit is the labelList with the
+    // region per cell.
+    regionSplit cellRegion(mesh_);
+
+    label regionI = -1;
+
+    label cellI = mesh_.findCell(keepPoint);
+
+    if (cellI != -1)
+    {
+        regionI = cellRegion[cellI];
+    }
+
+    reduce(regionI, maxOp<label>());
+
+    if (regionI == -1)
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::splitMeshRegions(const point&)"
+        )   << "Point " << keepPoint
+            << " is not inside the mesh." << nl
+            << "Bounding box of the mesh:" << mesh_.globalData().bb()
+            << exit(FatalError);
+    }
+
+    // Subset
+    // ~~~~~~
+
+    // Get cells to remove
+    DynamicList<label> cellsToRemove(mesh_.nCells());
+    forAll(cellRegion, cellI)
+    {
+        if (cellRegion[cellI] != regionI)
+        {
+            cellsToRemove.append(cellI);
+        }
+    }
+    cellsToRemove.shrink();
+
+    label nCellsToKeep = mesh_.nCells() - cellsToRemove.size();
+    reduce(nCellsToKeep, sumOp<label>());
+
+    Info<< "Keeping all cells in region " << regionI
+        << " containing point " << keepPoint << endl
+        << "Selected for keeping : "
+        << nCellsToKeep
+        << " cells." << endl;
+
+
+    // Remove cells
+    removeCells cellRemover(mesh_);
+
+    labelList exposedFaces(cellRemover.getExposedFaces(cellsToRemove));
+
+    if (exposedFaces.size() > 0)
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::splitMeshRegions(const point&)"
+        )   << "Removing non-reachable cells should only expose boundary faces"
+            << nl
+            << "ExposedFaces:" << exposedFaces << abort(FatalError);
+    }
+
+    return doRemoveCells
+    (
+        cellsToRemove,
+        exposedFaces,
+        labelList(exposedFaces.size(),-1),  // irrelevant since 0 size.
+        cellRemover
+    );
+}
+
+
+void Foam::meshRefinement::distribute(const mapDistributePolyMesh& map)
+{
+    // mesh_ already distributed; distribute my member data
+
+    // surfaceQueries_ ok.
+
+    // refinement
+    meshCutter_.distribute(map);
+
+    // surfaceIndex is face data.
+    map.distributeFaceData(surfaceIndex_);
+
+    // maintainedFaces are indices of faces.
+    forAll(userFaceData_, i)
+    {
+        map.distributeFaceData(userFaceData_[i].second());
+    }
+}
+
+
+void Foam::meshRefinement::updateMesh
+(
+    const mapPolyMesh& map,
+    const labelList& changedFaces
+)
+{
+    Map<label> dummyMap(0);
+
+    updateMesh(map, changedFaces, dummyMap, dummyMap, dummyMap);
+}
+
+
+void Foam::meshRefinement::storeData
+(
+    const labelList& pointsToStore,
+    const labelList& facesToStore,
+    const labelList& cellsToStore
+)
+{
+    // For now only meshCutter has storable/retrievable data.
+    meshCutter_.storeData
+    (
+        pointsToStore,
+        facesToStore,
+        cellsToStore
+    );
+}
+
+
+void Foam::meshRefinement::updateMesh
+(
+    const mapPolyMesh& map,
+    const labelList& changedFaces,
+    const Map<label>& pointsToRestore,
+    const Map<label>& facesToRestore,
+    const Map<label>& cellsToRestore
+)
+{
+    // For now only meshCutter has storable/retrievable data.
+
+    // Update numbering of cells/vertices.
+    meshCutter_.updateMesh
+    (
+        map,
+        pointsToRestore,
+        facesToRestore,
+        cellsToRestore
+    );
+
+    // Update surfaceIndex
+    updateList(map.faceMap(), -1, surfaceIndex_);
+
+    // Update cached intersection information
+    updateIntersections(changedFaces);
+
+    // Update maintained faces
+    forAll(userFaceData_, i)
+    {
+        labelList& data = userFaceData_[i].second();
+
+        if (userFaceData_[i].first() == KEEPALL)
+        {
+            // extend list with face-from-face data
+            updateList(map.faceMap(), -1, data);
+        }
+        else if (userFaceData_[i].first() == MASTERONLY)
+        {
+            // keep master only
+            labelList newFaceData(map.faceMap().size(), -1);
+
+            forAll(newFaceData, faceI)
+            {
+                label oldFaceI = map.faceMap()[faceI];
+
+                if (oldFaceI >= 0 && map.reverseFaceMap()[oldFaceI] == faceI)
+                {
+                    newFaceData[faceI] = data[oldFaceI];
+                }
+            }
+            data.transfer(newFaceData);
+        }
+        else
+        {
+            // remove any face that has been refined i.e. referenced more than
+            // once.
+
+            // 1. Determine all old faces that get referenced more than once.
+            // These get marked with -1 in reverseFaceMap
+            labelList reverseFaceMap(map.reverseFaceMap());
+
+            forAll(map.faceMap(), faceI)
+            {
+                label oldFaceI = map.faceMap()[faceI];
+
+                if (oldFaceI >= 0)
+                {
+                    if (reverseFaceMap[oldFaceI] != faceI)
+                    {
+                        // faceI is slave face. Mark old face.
+                        reverseFaceMap[oldFaceI] = -1;
+                    }
+                }
+            }
+
+            // 2. Map only faces with intact reverseFaceMap
+            labelList newFaceData(map.faceMap().size(), -1);
+            forAll(newFaceData, faceI)
+            {
+                label oldFaceI = map.faceMap()[faceI];
+
+                if (oldFaceI >= 0)
+                {
+                    if (reverseFaceMap[oldFaceI] == faceI)
+                    {
+                        newFaceData[faceI] = data[oldFaceI];
+                    }
+                }
+            }
+            data.transfer(newFaceData);
+        }
+    }
+}
+
+
+bool Foam::meshRefinement::write() const
+{
+    bool writeOk =
+        mesh_.write()
+     && meshCutter_.write()
+     && surfaceIndex_.write();
+
+    return writeOk;
+}
+
+
+void Foam::meshRefinement::printMeshInfo(const bool debug, const string& msg)
+ const
+{
+    const globalMeshData& pData = mesh_.globalData();
+
+    if (debug)
+    {
+        Pout<< msg.c_str()
+            << " : cells(local):" << mesh_.nCells()
+            << "  faces(local):" << mesh_.nFaces()
+            << "  points(local):" << mesh_.nPoints()
+            << endl;
+    }
+    else
+    {
+        Info<< msg.c_str()
+            << " : cells:" << pData.nTotalCells()
+            << "  faces:" << pData.nTotalFaces()
+            << "  points:" << pData.nTotalPoints()
+            << endl;
+    }
+
+
+    //if (debug)
+    {
+        const labelList& cellLevel = meshCutter_.cellLevel();
+
+        labelList nCells(gMax(cellLevel)+1, 0);
+
+        forAll(cellLevel, cellI)
+        {
+            nCells[cellLevel[cellI]]++;
+        }
+
+        Pstream::listCombineGather(nCells, plusEqOp<label>());
+        Pstream::listCombineScatter(nCells);
+
+        Info<< "Cells per refinement level:" << endl;
+        forAll(nCells, levelI)
+        {
+            Info<< "    " << levelI << '\t' << nCells[levelI]
+                << endl;
+        }
+    }
+}
+
+
+void Foam::meshRefinement::dumpRefinementLevel() const
+{
+    volScalarField volRefLevel
+    (
+        IOobject
+        (
+            "cellLevel",
+            mesh_.time().timeName(),
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE,
+            false
+        ),
+        mesh_,
+        dimensionedScalar("zero", dimless, 0)
+    );
+
+    const labelList& cellLevel = meshCutter_.cellLevel();
+
+    forAll(volRefLevel, cellI)
+    {
+        volRefLevel[cellI] = cellLevel[cellI];
+    }
+
+    volRefLevel.write();
+
+
+    pointMesh pMesh(mesh_);
+
+    pointScalarField pointRefLevel
+    (
+        IOobject
+        (
+            "pointLevel",
+            mesh_.time().timeName(),
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        pMesh,
+        dimensionedScalar("zero", dimless, 0)
+    );
+
+    const labelList& pointLevel = meshCutter_.pointLevel();
+
+    forAll(pointRefLevel, pointI)
+    {
+        pointRefLevel[pointI] = pointLevel[pointI];
+    }
+
+    pointRefLevel.write();
+}
+
+
+void Foam::meshRefinement::dumpIntersections(const fileName& prefix) const
+{
+    {
+        const pointField& cellCentres = mesh_.cellCentres();
+
+        OFstream str(prefix + "_edges.obj");
+        label vertI = 0;
+        Pout<< "meshRefinement::dumpIntersections :"
+            << " Writing cellcentre-cellcentre intersections to file "
+            << str.name() << endl;
+
+        // Internal faces
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            if (surfaceIndex_[faceI] != -1)
+            {
+                const point& ownCc = cellCentres[mesh_.faceOwner()[faceI]];
+                const point& neiCc = cellCentres[mesh_.faceNeighbour()[faceI]];
+
+                // Re-intersect to get position
+                pointIndexHit surfaceHitInfo;
+                surfaces_.findAnyIntersection(ownCc, neiCc, surfaceHitInfo);
+
+                meshTools::writeOBJ(str, ownCc);
+                vertI++;
+                meshTools::writeOBJ(str, surfaceHitInfo.hitPoint());
+                vertI++;
+                meshTools::writeOBJ(str, neiCc);
+                vertI++;
+                str << "l " << vertI-2 << ' ' << vertI-1 << nl
+                    << "l " << vertI-1 << ' ' << vertI << nl;
+            }
+        }
+
+        // Boundary faces
+
+        // Get boundary face centre and level. Coupled aware.
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+        pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+        calcNeighbourData(neiLevel, neiCc);
+
+        forAll(neiCc, i)
+        {
+            label faceI = i + mesh_.nInternalFaces();
+
+            if (surfaceIndex_[faceI] != -1)
+            {
+                const point& ownCc = cellCentres[mesh_.faceOwner()[faceI]];
+
+                // Re-intersect to get position
+                pointIndexHit surfaceHitInfo;
+                surfaces_.findAnyIntersection(ownCc, neiCc[i], surfaceHitInfo);
+
+                meshTools::writeOBJ(str, ownCc);
+                vertI++;
+                meshTools::writeOBJ(str, surfaceHitInfo.hitPoint());
+                vertI++;
+                meshTools::writeOBJ(str, neiCc[i]);
+                vertI++;
+                str << "l " << vertI-2 << ' ' << vertI-1 << nl
+                    << "l " << vertI-1 << ' ' << vertI << nl;
+            }
+        }
+    }
+
+    // Convert to vtk format
+    string cmd
+    (
+        "objToVTK " + prefix + "_edges.obj " + prefix + "_edges.vtk > /dev/null"
+    );
+    system(cmd.c_str());
+
+    Pout<< endl;
+}
+
+
+void Foam::meshRefinement::write
+(
+    const label flag,
+    const fileName& prefix
+) const
+{
+    if (flag & MESH)
+    {
+        write();
+    }
+    if (flag & SCALARLEVELS)
+    {
+        dumpRefinementLevel();
+    }
+    if (flag&OBJINTERSECTIONS && prefix.size()>0)
+    {
+        dumpIntersections(prefix);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
new file mode 100644
index 0000000000..c643f4d0f6
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
@@ -0,0 +1,667 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    meshRefinement
+
+Description
+    Helper class which maintains intersections of (changing) mesh with
+    (static) surfaces.
+    Maintains
+    - per face any intersections of this edge with any of the surfaces
+
+SourceFiles
+    meshRefinement.C
+    meshRefinementBaffles.C
+    meshRefinementMerge.C
+    meshRefinementRefine.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef meshRefinement_H
+#define meshRefinement_H
+
+#include "hexRef8.H"
+#include "mapPolyMesh.H"
+#include "autoPtr.H"
+#include "pointIOField.H"
+#include "labelPair.H"
+#include "indirectPrimitivePatch.H"
+#include "pointFieldsFwd.H"
+#include "Tuple2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class fvMesh;
+class mapDistributePolyMesh;
+class decompositionMethod;
+class refinementSurfaces;
+class removeCells;
+class featureEdgeMesh;
+class fvMeshDistribute;
+class searchableSurface;
+class regionSplit;
+
+/*---------------------------------------------------------------------------*\
+                           Class meshRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class meshRefinement
+{
+
+public:
+
+    // Public data types
+
+        //- Enumeration for debug dumping
+        enum writeFlag
+        {
+            MESH = 1,
+            SCALARLEVELS = 2,
+            OBJINTERSECTIONS = 4
+        };
+
+
+        //- Enumeration for how the userdata is to be mapped upon refinement.
+        enum mapType
+        {
+            MASTERONLY = 1, // maintain master only
+            KEEPALL = 2,    // have slaves (upon refinement) from master
+            REMOVE = 4      // set value to -1 any face that has been refined
+        };
+
+
+private:
+
+    // Private data
+
+        //- Reference to mesh
+        fvMesh& mesh_;
+
+        //- tolerance used for sorting coordinates (used in 'less' routine)
+        const scalar tol_;
+
+        const refinementSurfaces& surfaces_;
+
+        //- refinement engine
+        hexRef8 meshCutter_;
+
+        //- per cc-cc vector the index of the surface hit
+        labelIOList surfaceIndex_;
+
+        //- user supplied face based data.
+        List<Tuple2<mapType, labelList> > userFaceData_;
+
+
+    // Private Member Functions
+
+        //- Reorder list according to map.
+        template<class T>
+        static void updateList
+        (
+            const labelList& newToOld,
+            const T& nullValue,
+            List<T>& elems
+        );
+
+        //- Add patchfield of given type to all fields on mesh
+        template<class GeoField>
+        static void addPatchFields(fvMesh&, const word& patchFieldType);
+
+        //- Reorder patchfields of all fields on mesh
+        template<class GeoField>
+        static void reorderPatchFields(fvMesh&, const labelList& oldToNew);
+
+        //- Find out which faces have changed given cells (old mesh labels)
+        //  that were marked for refinement.
+        static labelList getChangedFaces
+        (
+            const mapPolyMesh&,
+            const labelList& oldCellsToRefine
+        );
+
+        //- Calculate coupled boundary end vector and refinement level
+        void calcNeighbourData
+        (
+            labelList& neiLevel,
+            pointField& neiCc
+        ) const;
+        ////- Calculate coupled boundary end vector and refinement level. Sort
+        ////  so both sides of coupled face have data in same order.
+        //void calcCanonicalBoundaryData
+        //(
+        //    labelList& leftLevel,
+        //    pointField& leftCc,
+        //    labelList& rightLevel,
+        //    pointField& rightCc
+        //)  const;
+
+        //- Find any intersection of surface. Store in surfaceIndex_.
+        void updateIntersections(const labelList& changedFaces);
+
+        //- Set instance of all local IOobjects
+        void setInstance(const fileName&);
+
+        //- Remove cells. Put exposedFaces into exposedPatchIDs.
+        autoPtr<mapPolyMesh> doRemoveCells
+        (
+            const labelList& cellsToRemove,
+            const labelList& exposedFaces,
+            const labelList& exposedPatchIDs,
+            removeCells& cellRemover
+        );
+
+        // Get cells which are inside any closed surface. Note that
+        // all closed surfaces
+        // will have already been oriented to have keepPoint outside.
+        labelList getInsideCells(const word&) const;
+
+        // Do all to remove inside cells
+        autoPtr<mapPolyMesh> removeInsideCells
+        (
+            const string& msg,
+            const label exposedPatchI
+        );
+
+        //- Used in decomposeCombineRegions. Given global region per cell
+        //  determines master processor/cell for regions straddling
+        //  procboundaries.
+        void getRegionMaster
+        (
+            const boolList& blockedFace,
+            const regionSplit& globalRegion,
+            Map<label>& regionToMaster
+        ) const;
+
+
+        // Refinement candidate selection
+
+            //- Mark cell for refinement (if not already marked). Return false
+            // if refinelimit hit. Keeps running count (in nRefine) of cells
+            // marked for refinement
+            static bool markForRefine
+            (
+                const label markValue,
+                const label nAllowRefine,
+                label& cellValue,
+                label& nRefine
+            );
+
+            //- Calculate list of cells to refine based on intersection of
+            //  features.
+            label markFeatureRefinement
+            (
+                const point& keepPoint,
+                const PtrList<featureEdgeMesh>& featureMeshes,
+                const labelList& featureLevels,
+                const label nAllowRefine,
+
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+            //- Mark cells for refinement-shells based refinement.
+            label markInternalRefinement
+            (
+                const PtrList<searchableSurface>&,
+                const labelList& shellLevels,
+                const boolList& shellRefineInside,
+                const label nAllowRefine,
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+            //- Mark cells for surface intersection based refinement.
+            label markSurfaceRefinement
+            (
+                const label nAllowRefine,
+                const labelList& neiLevel,
+                const pointField& neiCc,
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+            //- Mark cell if local curvature > curvature or
+            //  markDifferingRegions = true and intersections with different
+            //  regions.
+            bool checkCurvature
+            (
+                const labelList& globalToPatch,
+                const scalar curvature,
+                const bool markDifferingRegions,
+                const label nAllowRefine,
+                const label newSurfI,
+                const label newTriI,
+                const label cellI,
+
+                label& maxCellSurfI,
+                label& maxCellTriI,
+
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+
+            //- Mark cells for surface curvature based refinement. Marks if
+            //  local curvature > curvature or if on different regions
+            //  (markDifferingRegions)
+            label markSurfaceCurvatureRefinement
+            (
+                const labelList& globalToPatch,
+                const scalar curvature,
+                const bool markDifferingRegions,
+                const label nAllowRefine,
+                const labelList& neiLevel,
+                const pointField& neiCc,
+                labelList& refineCell,
+                label& nRefine
+            ) const;
+
+        // Baffle handling
+
+            //- Determine patches for baffles
+            void getBafflePatches
+            (
+                const labelList& globalToPatch,
+                const labelList& neiLevel,
+                const pointField& neiCc,
+                labelList& ownPatch,
+                labelList& neiPatch
+            ) const;
+
+            //- Determine patch for baffle using some heuristic (and not
+            //  surface)
+            label getBafflePatch
+            (
+                const labelList& facePatch,
+                const label faceI
+            ) const;
+
+            //- Repatches external face or creates baffle for internal face
+            //  with user specified patches (might be different for both sides).
+            //  Returns label of added face.
+            label createBaffle
+            (
+                const label faceI,
+                const label ownPatch,
+                const label neiPatch,
+                polyTopoChange& meshMod
+            ) const;
+
+            //- Helper function to mark face as being on 'boundary'. Used by
+            //  markFacesOnProblemCells
+            void markBoundaryFace
+            (
+                const label faceI,
+                boolList& isBoundaryFace,
+                boolList& isBoundaryEdge,
+                boolList& isBoundaryPoint
+            ) const;
+
+            //- Returns list with for every internal face -1 or the patch
+            //  they should be baffled into.
+            labelList markFacesOnProblemCells
+            (
+                const labelList& globalToPatch
+            ) const;
+
+
+        // Baffle merging
+
+            //- Extract those baffles (duplicate) faces that are on the edge
+            //  of a baffle region. These are candidates for merging.
+            List<labelPair> filterDuplicateFaces(const List<labelPair>&) const;
+
+
+        // Zone handling
+
+            //- Finds zone per cell for cells inside closed named surfaces.
+            //  (uses geometric test for insideness)
+            void findCellZoneGeometric
+            (
+                const labelList& closedNamedSurfaces,
+                const labelList& namedSurfaceIndex,
+                const labelList& surfaceToCellZone,
+                labelList& cellToZone
+            ) const;
+
+            //- Finds zone per cell. Uses topological walk with all faces
+            //  marked in namedSurfaceIndex regarded as blocked.
+            void findCellZoneTopo
+            (
+                const point& keepPoint,
+                const labelList& namedSurfaceIndex,
+                const labelList& surfaceToCellZone,
+                labelList& cellToZone
+            ) const;
+
+
+        //- Disallow default bitwise copy construct
+        meshRefinement(const meshRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const meshRefinement&);
+
+public:
+
+    //- Runtime type information
+    ClassName("meshRefinement");
+
+
+    // Constructors
+
+        //- Construct from components
+        meshRefinement
+        (
+            fvMesh& mesh,
+            const scalar tol,
+            const refinementSurfaces&
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //- reference to mesh
+            const fvMesh& mesh() const
+            {
+                return mesh_;
+            }
+            fvMesh& mesh()
+            {
+                return mesh_;
+            }
+
+            //- reference to surface search engines
+            const refinementSurfaces& surfaces() const
+            {
+                return surfaces_;
+            }
+
+            //- reference to meshcutting engine
+            const hexRef8& meshCutter() const
+            {
+                return meshCutter_;
+            }
+
+            //- per start-end edge the index of the surface hit
+            const labelList& surfaceIndex() const
+            {
+                return surfaceIndex_;
+            }
+
+            labelList& surfaceIndex()
+            {
+                return surfaceIndex_;
+            }
+
+            //- Additional face data that is maintained across
+            //  topo changes. Every entry is a list over all faces.
+            //  Bit of a hack. Additional flag to say whether to maintain master
+            //  only (false) or increase set to account for face-from-face.
+            const List<Tuple2<mapType, labelList> >& userFaceData() const
+            {
+                return userFaceData_;
+            }
+
+            List<Tuple2<mapType, labelList> >& userFaceData()
+            {
+                return userFaceData_;
+            }
+
+
+        // Other
+
+            //- Count number of intersections (local)
+            label countHits() const;
+
+            //- Helper function to get decomposition such that all connected
+            //  regions get moved onto one processor. Used to prevent baffles
+            //  straddling processor boundaries. explicitConnections is to
+            //  keep pairs of non-coupled boundary faces together
+            //  (e.g. to keep baffles together)
+            labelList decomposeCombineRegions
+            (
+                const boolList& blockedFace,
+                const List<labelPair>& explicitConnections,
+                decompositionMethod&
+            ) const;
+
+            //- Get faces with intersection.
+            labelList intersectedFaces() const;
+
+            //- Get points on surfaces with intersection and boundary faces.
+            labelList intersectedPoints() const;
+
+            //- Get added patches (inverse of globalToPatch)
+            static labelList addedPatches(const labelList& globalToPatch);
+
+            //- Create patch from set of patches
+            static autoPtr<indirectPrimitivePatch> makePatch
+            (
+                const polyMesh&,
+                const labelList&
+            );
+
+            //- Helper function to make a pointVectorField with correct
+            //  bcs for mesh movement:
+            //  - adaptPatchIDs         : fixedValue
+            //  - processor             : calculated (so free to move)
+            //  - cyclic/wedge/symmetry : slip
+            //  - other                 : slip
+            static tmp<pointVectorField> makeDisplacementField
+            (
+                const pointMesh& pMesh,
+                const labelList& adaptPatchIDs
+            );
+
+        // Refinement
+
+            //- Calculate list of cells to refine.
+            labelList refineCandidates
+            (
+                const point& keepPoint,
+                const labelList& globalToPatch,
+                const scalar curvature,
+
+                const PtrList<featureEdgeMesh>& featureMeshes,
+                const labelList& featureLevels,
+
+                const PtrList<searchableSurface>&,
+                const labelList& shellLevels,
+                const boolList& shellRefineInside,
+
+                const bool featureRefinement,
+                const bool internalRefinement,
+                const bool surfaceRefinement,
+                const bool curvatureRefinement,
+                const label maxGlobalCells,
+                const label maxLocalCells
+            ) const;
+
+            //- Refine some cells
+            autoPtr<mapPolyMesh> refine(const labelList& cellsToRefine);
+
+            //- Refine some cells and rebalance
+            autoPtr<mapDistributePolyMesh> refineAndBalance
+            (
+                const string& msg,
+                decompositionMethod& decomposer,
+                fvMeshDistribute& distributor,
+                const labelList& cellsToRefine
+            );
+
+
+        // Baffle handling
+
+            //- Split off unreachable areas of mesh.
+            void baffleAndSplitMesh
+            (
+                const bool handleSnapProblems,
+                const bool mergeFreeStanding,
+                Time& runTime,
+                const labelList& globalToPatch,
+                const point& keepPoint
+            );
+
+            //- Split off (with optional buffer layers) unreachable areas
+            //  of mesh. Does not introduce baffles.
+            autoPtr<mapPolyMesh> splitMesh
+            (
+                const label nBufferLayers,
+                const labelList& globalToPatch,
+                const point& keepPoint
+            );
+
+            //- Find boundary points that connect to more than one cell
+            //  region and split them.
+            autoPtr<mapPolyMesh> dupNonManifoldPoints();
+
+            //- Create baffle for every internal face where ownPatch != -1
+            autoPtr<mapPolyMesh> createBaffles
+            (
+                const labelList& ownPatch,
+                const labelList& neiPatch
+            );
+
+            //- Return a list of coupled face pairs, i.e. faces that
+            //  use the same vertices.
+            List<labelPair> getDuplicateFaces(const labelList& testFaces) const;
+
+            //- Merge baffles. Gets pairs of faces.
+            autoPtr<mapPolyMesh> mergeBaffles(const List<labelPair>&);
+
+            //- Put faces/cells into zones according to surface specification.
+            //  Returns null if no zone surfaces present. Region containing
+            //  the keepPoint will not be put into a cellZone.
+            autoPtr<mapPolyMesh> zonify(const point& keepPoint);
+
+
+        // Other topo changes
+
+            //- Helper function to add patch to mesh
+            static label addPatch(fvMesh&, const word& name, const word& type);
+
+            //- Split mesh. Keep part containing point.
+            autoPtr<mapPolyMesh> splitMeshRegions(const point& keepPoint);
+
+            //- Update local numbering for mesh redistribution
+            void distribute(const mapDistributePolyMesh&);
+
+            //- Update for external change to mesh. changedFaces are in new mesh
+            //  face labels.
+            void updateMesh(const mapPolyMesh&, const labelList& changedFaces);
+
+
+            // Restoring : is where other processes delete and reinsert data.
+
+                //- Signal points/face/cells for which to store data
+                void storeData
+                (
+                    const labelList& pointsToStore,
+                    const labelList& facesToStore,
+                    const labelList& cellsToStore
+                );
+
+                //- Update local numbering + undo
+                //  Data to restore given as new pointlabel + stored pointlabel
+                //  (i.e. what was in pointsToStore)
+                void updateMesh
+                (
+                    const mapPolyMesh&,
+                    const labelList& changedFaces,
+                    const Map<label>& pointsToRestore,
+                    const Map<label>& facesToRestore,
+                    const Map<label>& cellsToRestore
+                );
+
+
+            //- Merge faces on the same patch (usually from exposing refinement)
+            //  Returns global number of faces merged.
+            label mergePatchFaces
+            (
+                const scalar minCos,
+                const scalar concaveCos
+                //const dictionary& motionDict,
+                //const labelList& globalToPatch
+            );
+
+            //- Remove points not used by any face or points used
+            // by only two faces where the edges are in line
+            autoPtr<mapPolyMesh> mergeEdges(const scalar minCos);
+
+
+        // Debug/IO
+
+            //- Debugging: check that all faces still obey start()>end()
+            void checkData();
+
+            //- Compare two lists over all boundary faces
+            template<class T>
+            void testSyncBoundaryFaceList
+            (
+                const scalar tol,
+                const string&,
+                const UList<T>&,
+                const UList<T>&
+            ) const;
+
+            //- Print some mesh stats.
+            void printMeshInfo(const bool, const string&) const;
+
+            //- Write mesh and all data
+            bool write() const;
+
+            //- Write refinement level as volScalarFields for postprocessing
+            void dumpRefinementLevel() const;
+
+            //- Debug: Write intersection information to OBJ format
+            void dumpIntersections(const fileName& prefix) const;
+
+            //- Do any one of above IO functions. flag is combination of
+            //  writeFlag values.
+            void write(const label flag, const fileName&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "meshRefinementTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
new file mode 100644
index 0000000000..c37f3cc36d
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -0,0 +1,2719 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    meshRefinement
+
+\*----------------------------------------------------------------------------*/
+
+#include "meshRefinement.H"
+#include "fvMesh.H"
+#include "syncTools.H"
+#include "Time.H"
+#include "refinementSurfaces.H"
+#include "pointSet.H"
+#include "faceSet.H"
+#include "indirectPrimitivePatch.H"
+#include "polyTopoChange.H"
+#include "meshTools.H"
+#include "polyModifyFace.H"
+#include "polyModifyCell.H"
+#include "polyAddFace.H"
+#include "polyRemoveFace.H"
+#include "polyAddPoint.H"
+#include "localPointRegion.H"
+//#include "directDuplicatePoints.H"
+#include "OFstream.H"
+#include "regionSplit.H"
+#include "removeCells.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Repatches external face or creates baffle for internal face
+// with user specified patches (might be different for both sides).
+// Returns label of added face.
+Foam::label Foam::meshRefinement::createBaffle
+(
+    const label faceI,
+    const label ownPatch,
+    const label neiPatch,
+    polyTopoChange& meshMod
+) const
+{
+    const face& f = mesh_.faces()[faceI];
+    label zoneID = mesh_.faceZones().whichZone(faceI);
+    bool zoneFlip = false;
+
+    if (zoneID >= 0)
+    {
+        const faceZone& fZone = mesh_.faceZones()[zoneID];
+        zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+    }
+
+    meshMod.setAction
+    (
+        polyModifyFace
+        (
+            f,                          // modified face
+            faceI,                      // label of face
+            mesh_.faceOwner()[faceI],   // owner
+            -1,                         // neighbour
+            false,                      // face flip
+            ownPatch,                   // patch for face
+            false,                      // remove from zone
+            zoneID,                     // zone for face
+            zoneFlip                    // face flip in zone
+        )
+    );
+
+
+    label dupFaceI = -1;
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        if (neiPatch == -1)
+        {
+            FatalErrorIn
+            (
+                "meshRefinement::createBaffle"
+                "(const label, const label, const label, polyTopoChange&)"
+            )   << "No neighbour patch for internal face " << faceI
+                << " fc:" << mesh_.faceCentres()[faceI]
+                << " ownPatch:" << ownPatch << abort(FatalError);
+        }
+
+        dupFaceI = meshMod.setAction
+        (
+            polyAddFace
+            (
+                f.reverseFace(),            // modified face
+                mesh_.faceNeighbour()[faceI],// owner
+                -1,                         // neighbour
+                -1,                         // masterPointID
+                -1,                         // masterEdgeID
+                faceI,                      // masterFaceID,
+                false,                      // face flip
+                neiPatch,                   // patch for face
+                zoneID,                     // zone for face
+                zoneFlip                    // face flip in zone
+            )
+        );
+    }
+    return dupFaceI;
+}
+
+
+// Get an estimate for the patch the internal face should get. Bit heuristic.
+Foam::label Foam::meshRefinement::getBafflePatch
+(
+    const labelList& facePatch,
+    const label faceI
+) const
+{
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    // Loop over face points
+    // for each point check all faces patch IDs
+    // as soon as an ID >= 0 is found, break and assign that ID
+    // to the current face.
+    // Check first for real patch (so proper surface intersection and then
+    // in facePatch array for patches to block off faces
+
+    forAll(mesh_.faces()[faceI], fp)
+    {
+        label pointI = mesh_.faces()[faceI][fp];
+
+        forAll(mesh_.pointFaces()[pointI], pf)
+        {
+            label pFaceI = mesh_.pointFaces()[pointI][pf];
+
+            label patchI = patches.whichPatch(pFaceI);
+
+            if (patchI != -1 && !patches[patchI].coupled())
+            {
+                return patchI;
+            }
+            else if (facePatch[pFaceI] != -1)
+            {
+                return facePatch[pFaceI];
+            }
+        }
+    }
+
+    // Loop over owner and neighbour cells, looking for the first face with a
+    // valid patch number
+    const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+    forAll(ownFaces, i)
+    {
+        label cFaceI = ownFaces[i];
+
+        label patchI = patches.whichPatch(cFaceI);
+
+        if (patchI != -1 && !patches[patchI].coupled())
+        {
+            return patchI;
+        }
+        else if (facePatch[cFaceI] != -1)
+        {
+            return facePatch[cFaceI];
+        }
+    }
+
+    if (mesh_.isInternalFace(faceI))
+    {
+        const cell& neiFaces = mesh_.cells()[mesh_.faceNeighbour()[faceI]];
+
+        forAll(neiFaces, i)
+        {
+            label cFaceI = neiFaces[i];
+
+            label patchI = patches.whichPatch(cFaceI);
+
+            if (patchI != -1 && !patches[patchI].coupled())
+            {
+                return patchI;
+            }
+            else if (facePatch[cFaceI] != -1)
+            {
+                return facePatch[cFaceI];
+            }
+        }
+    }
+
+    WarningIn
+    (
+        "meshRefinement::getBafflePatch(const labelList& const label)"
+    )   << "Could not find boundary face neighbouring internal face "
+        << faceI << " with face centre " << mesh_.faceCentres()[faceI]
+        << nl
+        << "Using arbitrary patch " << 0 << " instead." << endl;
+
+    return 0;
+}
+
+
+// Determine patches for baffles.
+void Foam::meshRefinement::getBafflePatches
+(
+    const labelList& globalToPatch,
+    const labelList& neiLevel,
+    const pointField& neiCc,
+
+    labelList& ownPatch,
+    labelList& neiPatch
+) const
+{
+    autoPtr<OFstream> str;
+    label vertI = 0;
+    if (debug&OBJINTERSECTIONS)
+    {
+        str.reset(new OFstream(mesh_.time().path()/"intersections.obj"));
+
+        Pout<< "getBafflePatches : Writing surface intersections to file "
+            << str().name() << nl << endl;
+    }
+
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    // Build list of surfaces that are not to be baffled.
+    const wordList& cellZoneNames = surfaces_.cellZoneNames();
+
+    labelList surfacesToBaffle(cellZoneNames.size());
+    label baffleI = 0;
+    forAll(cellZoneNames, surfI)
+    {
+        if (cellZoneNames[surfI].size() > 0)
+        {
+            if (debug)
+            {
+                Pout<< "getBafflePatches : Not baffling surface "
+                    << surfaces_[surfI].searchableSurface::name() << endl;
+            }
+        }
+        else
+        {
+            surfacesToBaffle[baffleI++] = surfI;
+        }
+    }
+    surfacesToBaffle.setSize(baffleI);
+
+    ownPatch.setSize(mesh_.nFaces());
+    ownPatch = -1;
+    neiPatch.setSize(mesh_.nFaces());
+    neiPatch = -1;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            // Edge between owner and neighbour of face pierces a surface.
+            // Do closer inspection to find nearest intersection on both sides.
+
+            label own = mesh_.faceOwner()[faceI];
+
+            // Cc of neighbouring cell
+            point end
+            (
+                mesh_.isInternalFace(faceI)
+              ? cellCentres[mesh_.faceNeighbour()[faceI]]
+              : neiCc[faceI-mesh_.nInternalFaces()]
+            );
+
+            label surface1, surface2;
+            pointIndexHit hit1, hit2;
+            surfaces_.findNearestIntersection
+            (
+                surfacesToBaffle,
+                cellCentres[own],
+                end,
+
+                surface1,
+                hit1,
+                surface2,
+                hit2
+            );
+
+            if (hit1.hit() && hit2.hit())
+            {
+                if (str.valid())
+                {
+                    meshTools::writeOBJ(str(), cellCentres[own]);
+                    vertI++;
+                    meshTools::writeOBJ(str(), hit1.rawPoint());
+                    vertI++;
+                    meshTools::writeOBJ(str(), hit2.rawPoint());
+                    vertI++;
+                    meshTools::writeOBJ(str(), end);
+                    vertI++;
+                    str()<< "l " << vertI-3 << ' ' << vertI-2 << nl;
+                    str()<< "l " << vertI-2 << ' ' << vertI-1 << nl;
+                    str()<< "l " << vertI-1 << ' ' << vertI << nl;
+                }
+
+
+                // Pick up the patches
+                ownPatch[faceI] = globalToPatch
+                [
+                    surfaces_.triangleRegion(surface1, hit1.index())
+                ];
+                neiPatch[faceI] = globalToPatch
+                [
+                    surfaces_.triangleRegion(surface2, hit2.index())
+                ];
+
+                if (ownPatch[faceI] == -1 || neiPatch[faceI] == -1)
+                {
+                    FatalErrorIn("getBafflePatches()") << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // No need to parallel sync since intersection data (surfaceIndex_ etc.)
+    // already guaranteed to be synced...
+    // However:
+    // - owncc and neicc are reversed on different procs so might pick
+    //   up different regions reversed? No problem. Neighbour on one processor
+    //   might not be owner on the other processor but the neighbour is
+    //   not used when creating baffles from proc faces.
+    // - tolerances issues occasionally crop up.
+    syncTools::syncFaceList(mesh_, ownPatch, maxEqOp<label>(), false);
+    syncTools::syncFaceList(mesh_, neiPatch, maxEqOp<label>(), false);
+}
+
+
+// Create baffle for every face where ownPatch != -1
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createBaffles
+(
+    const labelList& ownPatch,
+    const labelList& neiPatch
+)
+{
+    if
+    (
+        ownPatch.size() != mesh_.nFaces()
+     || neiPatch.size() != mesh_.nFaces()
+    )
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::createBaffles"
+            "(const label, const labelList&, const labelList&)"
+        )   << "Illegal size :"
+            << " ownPatch:" << ownPatch.size()
+            << " neiPatch:" << neiPatch.size()
+            << ". Should be number of faces:" << mesh_.nFaces()
+            << abort(FatalError);
+    }
+
+    if (debug)
+    {
+        labelList syncedOwnPatch(ownPatch);
+        syncTools::syncFaceList(mesh_, syncedOwnPatch, maxEqOp<label>(), false);
+        labelList syncedNeiPatch(neiPatch);
+        syncTools::syncFaceList(mesh_, syncedNeiPatch, maxEqOp<label>(), false);
+
+        forAll(syncedOwnPatch, faceI)
+        {
+            if
+            (
+                (ownPatch[faceI] == -1 && syncedOwnPatch[faceI] != -1)
+             || (neiPatch[faceI] == -1 && syncedNeiPatch[faceI] != -1)
+            )
+            {
+                FatalErrorIn
+                (
+                    "meshRefinement::createBaffles"
+                    "(const label, const labelList&, const labelList&)"
+                )   << "Non synchronised at face:" << faceI
+                    << " on patch:" << mesh_.boundaryMesh().whichPatch(faceI)
+                    << " fc:" << mesh_.faceCentres()[faceI] << endl
+                    << "ownPatch:" << ownPatch[faceI]
+                    << " syncedOwnPatch:" << syncedOwnPatch[faceI]
+                    << " neiPatch:" << neiPatch[faceI]
+                    << " syncedNeiPatch:" << syncedNeiPatch[faceI]
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Topochange container
+    polyTopoChange meshMod(mesh_);
+
+    label nBaffles = 0;
+
+    forAll(ownPatch, faceI)
+    {
+        if (ownPatch[faceI] != -1)
+        {
+            // Create baffle or repatch face. Return label of inserted baffle
+            // face.
+            createBaffle
+            (
+                faceI,
+                ownPatch[faceI],   // owner side patch
+                neiPatch[faceI],   // neighbour side patch
+                meshMod
+            );
+            nBaffles++;
+        }
+    }
+
+    // Change the mesh (no inflation, parallel sync)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh if in inflation mode
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+    else
+    {
+        // Delete mesh volumes. No other way to do this?
+        mesh_.clearOut();
+    }
+
+    //- Redo the intersections on the newly create baffle faces. Note that
+    //  this changes also the cell centre positions.
+    labelHashSet baffledFacesSet(2*nBaffles);
+
+    const labelList& reverseFaceMap = map().reverseFaceMap();
+    const labelList& faceMap = map().faceMap();
+
+    // Pick up owner side of baffle
+    forAll(ownPatch, oldFaceI)
+    {
+        label faceI = reverseFaceMap[oldFaceI];
+
+        if (ownPatch[oldFaceI] != -1 && faceI >= 0)
+        {
+            const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+            forAll(ownFaces, i)
+            {
+                baffledFacesSet.insert(ownFaces[i]);
+            }
+        }
+    }
+    // Pick up neighbour side of baffle (added faces)
+    forAll(faceMap, faceI)
+    {
+        label oldFaceI = faceMap[faceI];
+
+        if (oldFaceI >= 0 && reverseFaceMap[oldFaceI] != faceI)
+        {
+            const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+            forAll(ownFaces, i)
+            {
+                baffledFacesSet.insert(ownFaces[i]);
+            }
+        }
+    }
+
+    updateMesh(map, baffledFacesSet.toc());
+
+    return map;
+}
+
+
+void Foam::meshRefinement::markBoundaryFace
+(
+    const label faceI,
+    boolList& isBoundaryFace,
+    boolList& isBoundaryEdge,
+    boolList& isBoundaryPoint
+) const
+{
+    isBoundaryFace[faceI] = true;
+
+    const labelList& fEdges = mesh_.faceEdges()[faceI];
+
+    forAll(fEdges, fp)
+    {
+        isBoundaryEdge[fEdges[fp]] = true;
+    }
+
+    const face& f = mesh_.faces()[faceI];
+
+    forAll(f, fp)
+    {
+        isBoundaryPoint[f[fp]] = true;
+    }
+}
+
+
+// Returns list with for every internal face -1 or the patch they should
+// be baffled into. Gets run after createBaffles so all the surface
+// intersections have already been turned into baffles. Used to remove cells
+// by baffling all their faces and have the splitMeshRegions chuck away non
+// used regions.
+Foam::labelList Foam::meshRefinement::markFacesOnProblemCells
+(
+    const labelList& globalToPatch
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const labelList& pointLevel = meshCutter_.pointLevel();
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+
+    // Per internal face (boundary faces not used) the patch that the
+    // baffle should get (or -1)
+    labelList facePatch(mesh_.nFaces(), -1);
+
+    // Mark all points and edges on baffle patches (so not on any inlets,
+    // outlets etc.)
+    boolList isBoundaryPoint(mesh_.nPoints(), false);
+    boolList isBoundaryEdge(mesh_.nEdges(), false);
+    boolList isBoundaryFace(mesh_.nFaces(), false);
+
+    // Fill boundary data. All elements on meshed patches get marked.
+    forAll(globalToPatch, i)
+    {
+        label patchI = globalToPatch[i];
+
+        if (patchI != -1)
+        {
+            const polyPatch& pp = patches[patchI];
+
+            label faceI = pp.start();
+
+            forAll(pp, j)
+            {
+                markBoundaryFace
+                (
+                    faceI,
+                    isBoundaryFace,
+                    isBoundaryEdge,
+                    isBoundaryPoint
+                );
+
+                faceI++;
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        isBoundaryPoint,
+        orEqOp<bool>(),
+        false,              // null value
+        false               // no separation
+    );
+
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        isBoundaryEdge,
+        orEqOp<bool>(),
+        false,              // null value
+        false               // no separation
+    );
+
+    syncTools::syncFaceList
+    (
+        mesh_,
+        isBoundaryFace,
+        orEqOp<bool>(),
+        false               // no separation
+    );
+
+
+    // For each cell count the number of anchor points that are on
+    // the boundary:
+    // 8 : check the number of (baffle) boundary faces. If 3 or more block
+    //     off the cell since the cell would get squeezed down to a diamond
+    //     (probably; if the 3 or more faces are unrefined (only use the
+    //      anchor points))
+    // 7 : store. Used to check later on whether there are points with
+    //     3 or more of these cells. (note that on a flat surface a boundary
+    //     point will only have 4 cells connected to it)
+
+    // Does cell have exactly 7 of its 8 anchor points on the boundary?
+    PackedList<1> hasSevenBoundaryAnchorPoints(mesh_.nCells(), 0u);
+    // If so what is the remaining non-boundary anchor point?
+    labelHashSet nonBoundaryAnchors(mesh_.nCells()/10000);
+
+    // Count of faces marked for baffling
+    label nBaffleFaces = 0;
+
+    forAll(cellLevel, cellI)
+    {
+        const labelList cPoints(meshCutter_.cellPoints(cellI));
+
+        // Get number of anchor points (pointLevel == cellLevel)
+
+        label nBoundaryAnchors = 0;
+        label nNonAnchorBoundary = 0;
+        label nonBoundaryAnchor = -1;
+
+        forAll(cPoints, i)
+        {
+            label pointI = cPoints[i];
+
+            if (pointLevel[pointI] <= cellLevel[cellI])
+            {
+                // Anchor point
+                if (isBoundaryPoint[pointI])
+                {
+                    nBoundaryAnchors++;
+                }
+                else
+                {
+                    // Anchor point which is not on the surface
+                    nonBoundaryAnchor = pointI;
+                }
+            }
+            else if (isBoundaryPoint[pointI])
+            {
+                nNonAnchorBoundary++;
+            }
+        }
+
+        if (nBoundaryAnchors == 8)
+        {
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            // Count boundary faces.
+            label nBfaces = 0;
+
+            forAll(cFaces, cFaceI)
+            {
+                if (isBoundaryFace[cFaces[cFaceI]])
+                {
+                    nBfaces++;
+                }
+            }
+
+            // If nBfaces > 1 make all non-boundary non-baffle faces baffles.
+            // We assume that this situation is where there is a single
+            // cell sticking out which would get flattened.
+
+            // Eugene: delete cell no matter what.
+            //if (nBfaces > 1)
+            {
+                forAll(cFaces, cf)
+                {
+                    label faceI = cFaces[cf];
+
+                    if (facePatch[faceI] == -1 && mesh_.isInternalFace(faceI))
+                    {
+                        facePatch[faceI] = getBafflePatch(facePatch, faceI);
+                        nBaffleFaces++;
+
+                        // Mark face as a 'boundary'
+                        markBoundaryFace
+                        (
+                            faceI,
+                            isBoundaryFace,
+                            isBoundaryEdge,
+                            isBoundaryPoint
+                        );
+                    }
+                }
+            }
+        }
+        else if (nBoundaryAnchors == 7)
+        {
+            // Mark the cell. Store the (single!) non-boundary anchor point.
+            hasSevenBoundaryAnchorPoints.set(cellI, 1u);
+            nonBoundaryAnchors.insert(nonBoundaryAnchor);
+        }
+    }
+
+
+    // Loop over all points. If a point is connected to 4 or more cells
+    // with 7 anchor points on the boundary set those cell's non-boundary faces
+    // to baffles
+    forAllConstIter(labelHashSet, nonBoundaryAnchors, iter)
+    {
+        label pointI = iter.key();
+
+        const labelList& pCells = mesh_.pointCells()[pointI];
+
+        // Count number of 'hasSevenBoundaryAnchorPoints' cells.
+        label n = 0;
+
+        forAll(pCells, i)
+        {
+            if (hasSevenBoundaryAnchorPoints.get(pCells[i]) == 1u)
+            {
+                n++;
+            }
+        }
+
+        if (n > 3)
+        {
+            // Point in danger of being what? Remove all 7-cells.
+            forAll(pCells, i)
+            {
+                label cellI = pCells[i];
+
+                if (hasSevenBoundaryAnchorPoints.get(cellI) == 1u)
+                {
+                    const cell& cFaces = mesh_.cells()[cellI];
+
+                    forAll(cFaces, cf)
+                    {
+                        label faceI = cFaces[cf];
+
+                        if
+                        (
+                            facePatch[faceI] == -1
+                         && mesh_.isInternalFace(faceI)
+                        )
+                        {
+                            facePatch[faceI] = getBafflePatch(facePatch, faceI);
+                            nBaffleFaces++;
+
+                            // Mark face as a 'boundary'
+                            markBoundaryFace
+                            (
+                                faceI,
+                                isBoundaryFace,
+                                isBoundaryEdge,
+                                isBoundaryPoint
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Sync all. (note that pointdata and facedata not used anymore but sync
+    // anyway)
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        isBoundaryPoint,
+        orEqOp<bool>(),
+        false,              // null value
+        false               // no separation
+    );
+
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        isBoundaryEdge,
+        orEqOp<bool>(),
+        false,              // null value
+        false               // no separation
+    );
+
+    syncTools::syncFaceList
+    (
+        mesh_,
+        isBoundaryFace,
+        orEqOp<bool>(),
+        false               // no separation
+    );
+
+
+    // Find faces with all edges on the boundary and make them baffles
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        if (facePatch[faceI] == -1)
+        {
+            const labelList& fEdges = mesh_.faceEdges()[faceI];
+            label nFaceBoundaryEdges = 0;
+
+            forAll(fEdges, fe)
+            {
+                if (isBoundaryEdge[fEdges[fe]])
+                {
+                    nFaceBoundaryEdges++;
+                }
+            }
+
+            if (nFaceBoundaryEdges == fEdges.size())
+            {
+                facePatch[faceI] = getBafflePatch(facePatch, faceI);
+                nBaffleFaces++;
+
+                // Do NOT update boundary data since this would grow blocked
+                // faces across gaps.
+            }
+        }
+    }
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        if (pp.coupled())
+        {
+            label faceI = pp.start();
+
+            forAll(pp, i)
+            {
+                if (facePatch[faceI] == -1)
+                {
+                    const labelList& fEdges = mesh_.faceEdges()[faceI];
+                    label nFaceBoundaryEdges = 0;
+
+                    forAll(fEdges, fe)
+                    {
+                        if (isBoundaryEdge[fEdges[fe]])
+                        {
+                            nFaceBoundaryEdges++;
+                        }
+                    }
+
+                    if (nFaceBoundaryEdges == fEdges.size())
+                    {
+                        facePatch[faceI] = getBafflePatch(facePatch, faceI);
+                        nBaffleFaces++;
+
+                        // Do NOT update boundary data since this would grow
+                        // blocked faces across gaps.
+                    }
+                }
+
+                faceI++;
+            }
+        }
+    }
+
+    Info<< "markFacesOnProblemCells : marked "
+        << returnReduce(nBaffleFaces, sumOp<label>())
+        << " additional internal faces to be converted into baffles."
+        << endl;
+
+    return facePatch;
+}
+
+
+// Return a list of coupled face pairs, i.e. faces that use the same vertices.
+// (this information is recalculated instead of maintained since would be too
+// hard across splitMeshRegions).
+Foam::List<Foam::labelPair> Foam::meshRefinement::getDuplicateFaces
+(
+    const labelList& testFaces
+) const
+{
+    labelList duplicateFace
+    (
+        localPointRegion::findDuplicateFaces
+        (
+            mesh_,
+            testFaces
+        )
+    );
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    // Convert into list of coupled face pairs (mesh face labels).
+    List<labelPair> duplicateFaces(testFaces.size());
+    label dupI = 0;
+
+    forAll(duplicateFace, i)
+    {
+        label otherFaceI = duplicateFace[i];
+
+        if (otherFaceI != -1 && i < otherFaceI)
+        {
+            label meshFace0 = testFaces[i];
+            label patch0 = patches.whichPatch(meshFace0);
+            label meshFace1 = testFaces[otherFaceI];
+            label patch1 = patches.whichPatch(meshFace1);
+
+            if
+            (
+                (patch0 != -1 && isA<processorPolyPatch>(patches[patch0]))
+             || (patch1 != -1 && isA<processorPolyPatch>(patches[patch1]))
+            )
+            {
+                FatalErrorIn
+                (
+                    "meshRefinement::getDuplicateFaces"
+                    "(const bool, const labelList&)"
+                )   << "One of two duplicate faces is on"
+                    << " processorPolyPatch."
+                    << "This is not allowed." << nl
+                    << "Face:" << meshFace0
+                    << " is on patch:" << patches[patch0].name()
+                    << nl
+                    << "Face:" << meshFace1
+                    << " is on patch:" << patches[patch1].name()
+                    << abort(FatalError);
+            }
+
+            duplicateFaces[dupI++] = labelPair(meshFace0, meshFace1);
+        }
+    }
+    duplicateFaces.setSize(dupI);
+
+    Info<< "getDuplicateFaces : found " << returnReduce(dupI, sumOp<label>())
+        << " pairs of duplicate faces." << nl << endl;
+
+
+    if (debug)
+    {
+        faceSet duplicateFaceSet(mesh_, "duplicateFaces", 2*dupI);
+
+        forAll(duplicateFaces, i)
+        {
+            duplicateFaceSet.insert(duplicateFaces[i][0]);
+            duplicateFaceSet.insert(duplicateFaces[i][1]);
+        }
+        Pout<< "Writing duplicate faces (baffles) to faceSet "
+            << duplicateFaceSet.name() << nl << endl;
+        duplicateFaceSet.write();
+    }
+
+    return duplicateFaces;
+}
+
+
+// Extract those baffles (duplicate) faces that are on the edge of a baffle
+// region. These are candidates for merging.
+// Done by counting the number of baffles faces per mesh edge. If edge
+// has 2 boundary faces and both are baffle faces it is the edge of a baffle
+// region.
+Foam::List<Foam::labelPair> Foam::meshRefinement::filterDuplicateFaces
+(
+    const List<labelPair>& couples
+) const
+{
+    // Construct addressing engine for all duplicate faces (only one
+    // for each pair)
+
+    // Duplicate faces in mesh labels (first face of each pair only)
+    // (reused later on to mark off filtered couples. see below)
+    labelList duplicateFaces(couples.size());
+
+
+    // All duplicate faces on edge of the patch are to be merged.
+    // So we count for all edges of duplicate faces how many duplicate
+    // faces use them.
+    labelList nBafflesPerEdge(mesh_.nEdges(), 0);
+
+
+    // Count number of boundary faces per edge
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        // Count number of boundary faces. Discard coupled boundary faces.
+        if (!pp.coupled())
+        {
+            label faceI = pp.start();
+
+            forAll(pp, i)
+            {
+                const labelList& fEdges = mesh_.faceEdges()[faceI];
+
+                forAll(fEdges, fEdgeI)
+                {
+                    nBafflesPerEdge[fEdges[fEdgeI]]++;
+                }
+                faceI++;
+            }
+        }
+    }
+
+
+    // Count number of duplicate boundary faces per edge
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(couples, i)
+    {
+        const labelList& fEdges0 = mesh_.faceEdges()[couples[i].first()];
+
+        forAll(fEdges0, fEdgeI)
+        {
+            nBafflesPerEdge[fEdges0[fEdgeI]] += 1000000;
+        }
+
+        const labelList& fEdges1 = mesh_.faceEdges()[couples[i].second()];
+
+        forAll(fEdges1, fEdgeI)
+        {
+            nBafflesPerEdge[fEdges1[fEdgeI]] += 1000000;
+        }
+    }
+
+    // Add nBaffles on shared edges
+    syncTools::syncEdgeList
+    (
+        mesh_,
+        nBafflesPerEdge,
+        plusEqOp<label>(),  // in-place add
+        0,                  // initial value
+        false               // no separation
+    );
+
+
+    // Baffles which are not next to other boundaries and baffles will have
+    // value 2*1000000+2*1
+
+    List<labelPair> filteredCouples(couples.size());
+    label filterI = 0;
+
+    forAll(couples, i)
+    {
+        const labelPair& couple = couples[i];
+
+        if
+        (
+            patches.whichPatch(couple.first())
+         == patches.whichPatch(couple.second())
+        )
+        {
+            const labelList& fEdges = mesh_.faceEdges()[couples[i].first()];
+
+            forAll(fEdges, fEdgeI)
+            {
+                label edgeI = fEdges[fEdgeI];
+
+                if (nBafflesPerEdge[edgeI] == 2*1000000+2*1)
+                {
+                    filteredCouples[filterI++] = couples[i];
+                    break;
+                }
+            }
+        }
+    }
+    filteredCouples.setSize(filterI);
+
+    //Info<< "filterDuplicateFaces : from "
+    //    << returnReduce(couples.size(), sumOp<label>())
+    //    << " down to "
+    //    << returnReduce(filteredCouples.size(), sumOp<label>())
+    //    << " baffles." << nl << endl;
+
+    return filteredCouples;
+}
+
+
+// Merge baffles. Gets pairs of faces.
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeBaffles
+(
+    const List<labelPair>& couples
+)
+{
+    // Mesh change engine
+    polyTopoChange meshMod(mesh_);
+
+    const faceList& faces = mesh_.faces();
+    const labelList& faceOwner = mesh_.faceOwner();
+    const faceZoneMesh& faceZones = mesh_.faceZones();
+
+    forAll(couples, i)
+    {
+        label face0 = couples[i].first();
+        label face1 = couples[i].second();
+
+        // face1 < 0 signals a coupled face that has been converted to baffle.
+
+        label own0 = faceOwner[face0];
+        label own1 = faceOwner[face1];
+
+        if (face1 < 0 || own0 < own1)
+        {
+            // Use face0 as the new internal face.
+            label zoneID = faceZones.whichZone(face0);
+            bool zoneFlip = false;
+
+            if (zoneID >= 0)
+            {
+                const faceZone& fZone = faceZones[zoneID];
+                zoneFlip = fZone.flipMap()[fZone.whichFace(face0)];
+            }
+
+            label nei = (face1 < 0 ? -1 : own1);
+
+            meshMod.setAction(polyRemoveFace(face1));
+            meshMod.setAction
+            (
+                polyModifyFace
+                (
+                    faces[face0],           // modified face
+                    face0,                  // label of face being modified
+                    own0,                   // owner
+                    nei,                    // neighbour
+                    false,                  // face flip
+                    -1,                     // patch for face
+                    false,                  // remove from zone
+                    zoneID,                 // zone for face
+                    zoneFlip                // face flip in zone
+                )
+            );
+        }
+        else
+        {
+            // Use face1 as the new internal face.
+            label zoneID = faceZones.whichZone(face1);
+            bool zoneFlip = false;
+
+            if (zoneID >= 0)
+            {
+                const faceZone& fZone = faceZones[zoneID];
+                zoneFlip = fZone.flipMap()[fZone.whichFace(face1)];
+            }
+
+            meshMod.setAction(polyRemoveFace(face0));
+            meshMod.setAction
+            (
+                polyModifyFace
+                (
+                    faces[face1],           // modified face
+                    face1,                  // label of face being modified
+                    own1,                   // owner
+                    own0,                   // neighbour
+                    false,                  // face flip
+                    -1,                     // patch for face
+                    false,                  // remove from zone
+                    zoneID,                 // zone for face
+                    zoneFlip                // face flip in zone
+                )
+            );
+        }
+    }
+
+    // Change the mesh (no inflation)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh (since morphing does not do this)
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+    else
+    {
+        // Delete mesh volumes. No other way to do this?
+        mesh_.clearOut();
+    }
+
+    // Update intersections. Recalculate intersections on merged faces since
+    // this seems to give problems? Note: should not be nessecary since
+    // baffles preserve intersections from when they were created.
+    labelList newExposedFaces(2*couples.size());
+    label newI = 0;
+
+    forAll(couples, i)
+    {
+        label newFace0 = map().reverseFaceMap()[couples[i].first()];
+        if (newFace0 != -1)
+        {
+            newExposedFaces[newI++] = newFace0;
+        }
+
+        label newFace1 = map().reverseFaceMap()[couples[i].second()];
+        if (newFace1 != -1)
+        {
+            newExposedFaces[newI++] = newFace1;
+        }
+    }
+    newExposedFaces.setSize(newI);
+    updateMesh(map, newExposedFaces);
+
+    return map;
+}
+
+
+// Finds region per cell for cells inside closed named surfaces
+void Foam::meshRefinement::findCellZoneGeometric
+(
+    const labelList& closedNamedSurfaces,   // indices of closed surfaces
+    const labelList& namedSurfaceIndex,     // per face index of named surface
+    const labelList& surfaceToCellZone,     // cell zone index per surface
+
+    labelList& cellToZone
+) const
+{
+    const pointField& cellCentres = mesh_.cellCentres();
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+
+    forAll(cellToZone, cellI)
+    {
+        if (cellToZone[cellI] == -2)
+        {
+            label surfI = surfaces_.insideZone
+            (
+                closedNamedSurfaces,
+                cellCentres[cellI]
+            );
+
+            if (surfI != -1)
+            {
+                cellToZone[cellI] = surfaceToCellZone[surfI];
+            }
+        }
+    }
+
+
+    // Some cells with cell centres close to surface might have
+    // had been put into wrong surface. Recheck with perturbed cell centre.
+    forAll(namedSurfaceIndex, faceI)
+    {
+        label surfI = namedSurfaceIndex[faceI];
+
+        if (surfI != -1)
+        {
+            label own = faceOwner[faceI];
+            const point& ownCc = cellCentres[own];
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = faceNeighbour[faceI];
+                const point& neiCc = cellCentres[nei];
+
+                const vector d = 1E-4*(neiCc - ownCc);
+
+                // Test perturbed owner
+                {
+                    label ownSurfI = surfaces_.insideZone
+                    (
+                        closedNamedSurfaces,
+                        ownCc-d
+                    );
+
+                    if (ownSurfI != -1)
+                    {
+                        cellToZone[own] = surfaceToCellZone[ownSurfI];
+                    }
+                }
+
+                // Test perturbed neighbour
+                {
+                    label neiSurfI = surfaces_.insideZone
+                    (
+                        closedNamedSurfaces,
+                        neiCc+d
+                    );
+
+                    if (neiSurfI != -1)
+                    {
+                        cellToZone[nei] = surfaceToCellZone[neiSurfI];
+                    }
+                }
+            }
+            else
+            {
+                const point& neiCc = mesh_.faceCentres()[faceI];
+
+                const vector d = 1E-4*(neiCc - ownCc);
+
+                // Test perturbed owner
+                {
+                    label ownSurfI = surfaces_.insideZone
+                    (
+                        closedNamedSurfaces,
+                        ownCc-d
+                    );
+
+                    if (ownSurfI != -1)
+                    {
+                        cellToZone[own] = surfaceToCellZone[ownSurfI];
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+// Finds region per cell. Assumes:
+// - region containing keepPoint does not go into a cellZone
+// - all other regions can be found by crossing faces marked in
+//   namedSurfaceIndex.
+void Foam::meshRefinement::findCellZoneTopo
+(
+    const point& keepPoint,
+    const labelList& namedSurfaceIndex,
+    const labelList& surfaceToCellZone,
+    labelList& cellToZone
+) const
+{
+    // Analyse regions. Reuse regionsplit
+    boolList blockedFace(mesh_.nFaces());
+
+    forAll(namedSurfaceIndex, faceI)
+    {
+        if (namedSurfaceIndex[faceI] == -1)
+        {
+            blockedFace[faceI] = false;
+        }
+        else
+        {
+            blockedFace[faceI] = true;
+        }
+    }
+    syncTools::syncFaceList(mesh_, blockedFace, orEqOp<bool>(), false);
+
+    // Set region per cell based on walking
+    regionSplit cellRegion(mesh_, blockedFace);
+    blockedFace.clear();
+
+    // Per mesh region the zone the cell should be put in.
+    // -2   : not analysed yet
+    // -1   : keepPoint region. Not put into any cellzone.
+    // >= 0 : index of cellZone
+    labelList regionToCellZone(cellRegion.nRegions(), -2);
+
+    // See which cells already are set in the cellToZone (from geometric
+    // searching) and use these to take over their zones.
+    // Note: could be improved to count number of cells per region.
+    forAll(cellToZone, cellI)
+    {
+        if (cellToZone[cellI] != -2)
+        {
+            regionToCellZone[cellRegion[cellI]] = cellToZone[cellI];
+        }
+    }
+
+
+
+    // Find the region containing the keepPoint
+    label keepRegionI = -1;
+
+    label cellI = mesh_.findCell(keepPoint);
+
+    if (cellI != -1)
+    {
+        keepRegionI = cellRegion[cellI];
+    }
+    reduce(keepRegionI, maxOp<label>());
+
+    Info<< "Found point " << keepPoint << " in cell " << cellI
+        << " in global region " << keepRegionI
+        << " out of " << cellRegion.nRegions() << " regions." << endl;
+
+    if (keepRegionI == -1)
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::findCellZoneTopo"
+            "(const point&, const labelList&, const labelList&, labelList&)"
+        )   << "Point " << keepPoint
+            << " is not inside the mesh." << nl
+            << "Bounding box of the mesh:" << mesh_.globalData().bb()
+            << exit(FatalError);
+    }
+
+    // Mark default region with zone -1.
+    if (regionToCellZone[keepRegionI] == -2)
+    {
+        regionToCellZone[keepRegionI] = -1;
+    }
+
+
+    // Find correspondence between cell zone and surface
+    // by changing cell zone every time we cross a surface.
+    while (true)
+    {
+        bool changed = false;
+
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            label surfI = namedSurfaceIndex[faceI];
+
+            if (surfI != -1)
+            {
+                // Get cell zone that surface cells are in
+                label surfZoneI = surfaceToCellZone[surfI];
+
+                // Check whether inbetween different regions
+                label ownRegion = cellRegion[mesh_.faceOwner()[faceI]];
+                label neiRegion = cellRegion[mesh_.faceNeighbour()[faceI]];
+
+                if (ownRegion != neiRegion)
+                {
+                    // Jump. Change one of the sides to my type.
+
+                    // 1. Interface between my type and unset region.
+                    // Set region to keepRegion
+
+                    if (regionToCellZone[ownRegion] == -2)
+                    {
+                        if (regionToCellZone[neiRegion] == surfZoneI)
+                        {
+                            // Face between unset and my region. Put unset
+                            // region into keepRegion
+                            regionToCellZone[ownRegion] = -1;
+                            changed = true;
+                        }
+                        else if (regionToCellZone[neiRegion] != -2)
+                        {
+                            // Face between unset and other region.
+                            // Put unset region into my region
+                            regionToCellZone[ownRegion] = surfZoneI;
+                            changed = true;
+                        }
+                    }
+                    else if (regionToCellZone[neiRegion] == -2)
+                    {
+                        if (regionToCellZone[ownRegion] == surfZoneI)
+                        {
+                            // Face between unset and my region. Put unset
+                            // region into keepRegion
+                            regionToCellZone[neiRegion] = -1;
+                            changed = true;
+                        }
+                        else if (regionToCellZone[ownRegion] != -2)
+                        {
+                            // Face between unset and other region.
+                            // Put unset region into my region
+                            regionToCellZone[neiRegion] = surfZoneI;
+                            changed = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!returnReduce(changed, orOp<bool>()))
+        {
+            break;
+        }
+    }
+
+
+    // Synchronise regionToCellZone.
+    // Note:
+    // - region numbers are identical on all processors
+    // - keepRegion is identical ,,
+    // - cellZones are identical ,,
+    Pstream::listCombineGather(regionToCellZone, maxEqOp<label>());
+    Pstream::listCombineScatter(regionToCellZone);
+
+
+    forAll(regionToCellZone, regionI)
+    {
+        label zoneI = regionToCellZone[regionI];
+
+        if (zoneI ==  -2)
+        {
+            FatalErrorIn
+            (
+                "meshRefinement::findCellZoneTopo"
+                "(const point&, const labelList&, const labelList&, labelList&)"
+            )   << "For region " << regionI << " haven't set cell zone."
+                << exit(FatalError);
+        }
+    }
+
+    if (debug)
+    {
+        forAll(regionToCellZone, regionI)
+        {
+            Pout<< "Region " << regionI
+                << " becomes cellZone:" << regionToCellZone[regionI]
+                << endl;
+        }
+    }
+
+    // Rework into cellToZone
+    forAll(cellToZone, cellI)
+    {
+        cellToZone[cellI] = regionToCellZone[cellRegion[cellI]];
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Split off unreachable areas of mesh.
+void Foam::meshRefinement::baffleAndSplitMesh
+(
+    const bool handleSnapProblems,
+    const bool mergeFreeStanding,
+    Time& runTime,
+    const labelList& globalToPatch,
+    const point& keepPoint
+)
+{
+    // Introduce baffles
+    // ~~~~~~~~~~~~~~~~~
+
+    // Split the mesh along internal faces wherever there is a pierce between
+    // two cell centres.
+
+    Info<< "Introducing baffles for "
+        << returnReduce(countHits(), sumOp<label>())
+        << " faces that are intersected by the surface." << nl << endl;
+
+    // Swap neighbouring cell centres and cell level
+    labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+    pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+    calcNeighbourData(neiLevel, neiCc);
+
+    labelList ownPatch, neiPatch;
+    getBafflePatches
+    (
+        globalToPatch,
+        neiLevel,
+        neiCc,
+
+        ownPatch,
+        neiPatch
+    );
+    createBaffles(ownPatch, neiPatch);
+
+    if (debug)
+    {
+        // Debug:test all is still synced across proc patches
+        checkData();
+    }
+
+    Info<< "Created baffles in = "
+        << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+    printMeshInfo(debug, "After introducing baffles");
+
+    if (debug)
+    {
+        Pout<< "Writing baffled mesh to time " << mesh_.time().timeName()
+            << endl;
+        write(debug, runTime.path()/"baffles");
+        Pout<< "Dumped debug data in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+
+
+    // Introduce baffles to delete problem cells
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Create some additional baffles where we want surface cells removed.
+
+    if (handleSnapProblems)
+    {
+        Info<< nl
+            << "Introducing baffles to block off problem cells" << nl
+            << "----------------------------------------------" << nl
+            << endl;
+
+        labelList facePatch
+        (
+            markFacesOnProblemCells
+            (
+                globalToPatch
+            )
+        );
+        Info<< "Analyzed problem cells in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+        Info<< "Introducing baffles to delete problem cells." << nl << endl;
+
+        if (debug)
+        {
+            runTime++;
+        }
+
+        // Create baffles with same owner and neighbour for now.
+        createBaffles(facePatch, facePatch);
+
+        if (debug)
+        {
+            // Debug:test all is still synced across proc patches
+            checkData();
+        }
+        Info<< "Created baffles in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+        printMeshInfo(debug, "After introducing baffles");
+
+        if (debug)
+        {
+            Pout<< "Writing extra baffled mesh to time "
+                << mesh_.time().timeName() << endl;
+            write(debug, runTime.path()/"extraBaffles");
+            Pout<< "Dumped debug data in = "
+                << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+        }
+    }
+
+
+    // Select part of mesh
+    // ~~~~~~~~~~~~~~~~~~~
+
+    Info<< nl
+        << "Remove unreachable sections of mesh" << nl
+        << "-----------------------------------" << nl
+        << endl;
+
+    if (debug)
+    {
+        runTime++;
+    }
+
+    splitMeshRegions(keepPoint);
+
+    if (debug)
+    {
+        // Debug:test all is still synced across proc patches
+        checkData();
+    }
+    Info<< "Split mesh in = "
+        << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+
+    printMeshInfo(debug, "After subsetting");
+
+    if (debug)
+    {
+        Pout<< "Writing subsetted mesh to time " << mesh_.time().timeName()
+            << endl;
+        write(debug, runTime.path()/runTime.timeName());
+        Pout<< "Dumped debug data in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+
+
+    // Merge baffles
+    // ~~~~~~~~~~~~~
+
+    if (mergeFreeStanding)
+    {
+        Info<< nl
+            << "Merge free-standing baffles" << nl
+            << "---------------------------" << nl
+            << endl;
+
+        if (debug)
+        {
+            runTime++;
+        }
+
+        // List of pairs of freestanding baffle faces.
+        List<labelPair> couples
+        (
+            filterDuplicateFaces    // filter out freestanding baffles
+            (
+                getDuplicateFaces   // get all baffles
+                (
+                    identity(mesh_.nFaces()-mesh_.nInternalFaces())
+                   +mesh_.nInternalFaces()
+                )
+            )
+        );
+
+        label nCouples = couples.size();
+        reduce(nCouples, sumOp<label>());
+
+        Info<< "Detected free-standing baffles : " << nCouples << endl;
+
+        if (nCouples > 0)
+        {
+            // Actually merge baffles. Note: not exactly parallellized. Should
+            // convert baffle faces into processor faces if they resulted
+            // from them.
+            mergeBaffles(couples);
+
+            if (debug)
+            {
+                // Debug:test all is still synced across proc patches
+                checkData();
+            }
+        }
+        Info<< "Merged free-standing baffles in = "
+            << runTime.cpuTimeIncrement() << " s\n" << nl << endl;
+    }
+}
+
+
+// Split off (with optional buffer layers) unreachable areas of mesh.
+Foam::autoPtr<Foam::mapPolyMesh>  Foam::meshRefinement::splitMesh
+(
+    const label nBufferLayers,
+    const labelList& globalToPatch,
+    const point& keepPoint
+)
+{
+    // Determine patches to put intersections into
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Swap neighbouring cell centres and cell level
+    labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+    pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+    calcNeighbourData(neiLevel, neiCc);
+
+    labelList ownPatch, neiPatch;
+    getBafflePatches
+    (
+        globalToPatch,
+        neiLevel,
+        neiCc,
+
+        ownPatch,
+        neiPatch
+    );
+
+    // Analyse regions. Reuse regionsplit
+    boolList blockedFace(mesh_.nFaces(), false);
+
+    forAll(ownPatch, faceI)
+    {
+        if (ownPatch[faceI] != -1 || neiPatch[faceI] != -1)
+        {
+            blockedFace[faceI] = true;
+        }
+    }
+    syncTools::syncFaceList(mesh_, blockedFace, orEqOp<bool>(), false);
+
+    // Set region per cell based on walking
+    regionSplit cellRegion(mesh_, blockedFace);
+    blockedFace.clear();
+
+    // Find the region containing the keepPoint
+    label keepRegionI = -1;
+
+    label cellI = mesh_.findCell(keepPoint);
+
+    if (cellI != -1)
+    {
+        keepRegionI = cellRegion[cellI];
+    }
+    reduce(keepRegionI, maxOp<label>());
+
+    Info<< "Found point " << keepPoint << " in cell " << cellI
+        << " in global region " << keepRegionI
+        << " out of " << cellRegion.nRegions() << " regions." << endl;
+
+    if (keepRegionI == -1)
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::findCellZoneTopo"
+            "(const point&, const labelList&, const labelList&, labelList&)"
+        )   << "Point " << keepPoint
+            << " is not inside the mesh." << nl
+            << "Bounding box of the mesh:" << mesh_.globalData().bb()
+            << exit(FatalError);
+    }
+
+
+    // Walk out nBufferlayers from region split
+    // (modifies cellRegion, ownPatch)
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Takes over face patch onto points and then back to faces and cells
+    // (so cell-face-point walk)
+
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+
+    // Patch for exposed faces for lack of anything sensible.
+    const label defaultPatch = globalToPatch[0];
+
+    for (label i = 0; i < nBufferLayers; i++)
+    {
+        // 1. From cells (via faces) to points
+
+        labelList pointBaffle(mesh_.nPoints(), -1);
+
+        forAll(faceNeighbour, faceI)
+        {
+            const face& f = mesh_.faces()[faceI];
+
+            label ownRegion = cellRegion[faceOwner[faceI]];
+            label neiRegion = cellRegion[faceNeighbour[faceI]];
+
+            if (ownRegion == keepRegionI && neiRegion != keepRegionI)
+            {
+                // Note max(..) since possibly regionSplit might have split
+                // off extra unreachable parts of mesh. Note: or can this only
+                // happen for boundary faces?
+                forAll(f, fp)
+                {
+                    pointBaffle[f[fp]] = max(defaultPatch, ownPatch[faceI]);
+                }
+            }
+            else if (ownRegion != keepRegionI && neiRegion == keepRegionI)
+            {
+                label newPatchI = neiPatch[faceI];
+                if (newPatchI == -1)
+                {
+                    newPatchI = max(defaultPatch, ownPatch[faceI]);
+                }
+                forAll(f, fp)
+                {
+                    pointBaffle[f[fp]] = newPatchI;
+                }
+            }
+        }
+        for
+        (
+            label faceI = mesh_.nInternalFaces();
+            faceI < mesh_.nFaces();
+            faceI++
+        )
+        {
+            const face& f = mesh_.faces()[faceI];
+
+            label ownRegion = cellRegion[faceOwner[faceI]];
+
+            if (ownRegion == keepRegionI)
+            {
+                forAll(f, fp)
+                {
+                    pointBaffle[f[fp]] = max(defaultPatch, ownPatch[faceI]);
+                }
+            }
+        }
+
+        // Sync
+        syncTools::syncPointList
+        (
+            mesh_,
+            pointBaffle,
+            maxEqOp<label>(),
+            -1,                 // null value
+            false               // no separation
+        );
+
+
+        // 2. From points back to faces
+
+        const labelListList& pointFaces = mesh_.pointFaces();
+
+        forAll(pointFaces, pointI)
+        {
+            if (pointBaffle[pointI] != -1)
+            {
+                const labelList& pFaces = pointFaces[pointI];
+
+                forAll(pFaces, pFaceI)
+                {
+                    label faceI = pFaces[pFaceI];
+
+                    if (ownPatch[faceI] == -1)
+                    {
+                        ownPatch[faceI] = pointBaffle[pointI];
+                    }
+                }
+            }
+        }
+        syncTools::syncFaceList(mesh_, ownPatch, maxEqOp<label>(), false);
+
+
+        // 3. From faces to cells (cellRegion) and back to faces (ownPatch)
+
+        labelList newOwnPatch(ownPatch);
+
+        forAll(ownPatch, faceI)
+        {
+            if (ownPatch[faceI] != -1)
+            {
+                label own = faceOwner[faceI];
+
+                if (cellRegion[own] != keepRegionI)
+                {
+                    cellRegion[own] = keepRegionI;
+
+                    const cell& ownFaces = mesh_.cells()[own];
+                    forAll(ownFaces, j)
+                    {
+                        if (ownPatch[ownFaces[j]] == -1)
+                        {
+                            newOwnPatch[ownFaces[j]] = ownPatch[faceI];
+                        }
+                    }
+                }
+                if (mesh_.isInternalFace(faceI))
+                {
+                    label nei = faceNeighbour[faceI];
+
+                    if (cellRegion[nei] != keepRegionI)
+                    {
+                        cellRegion[nei] = keepRegionI;
+
+                        const cell& neiFaces = mesh_.cells()[nei];
+                        forAll(neiFaces, j)
+                        {
+                            if (ownPatch[neiFaces[j]] == -1)
+                            {
+                                newOwnPatch[neiFaces[j]] = ownPatch[faceI];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        ownPatch.transfer(newOwnPatch);
+
+        syncTools::syncFaceList(mesh_, ownPatch, maxEqOp<label>(), false);
+    }
+
+
+
+    // Subset
+    // ~~~~~~
+
+    // Get cells to remove
+    DynamicList<label> cellsToRemove(mesh_.nCells());
+    forAll(cellRegion, cellI)
+    {
+        if (cellRegion[cellI] != keepRegionI)
+        {
+            cellsToRemove.append(cellI);
+        }
+    }
+    cellsToRemove.shrink();
+
+    label nCellsToKeep = mesh_.nCells() - cellsToRemove.size();
+    reduce(nCellsToKeep, sumOp<label>());
+
+    Info<< "Keeping all cells in region " << keepRegionI
+        << " containing point " << keepPoint << endl
+        << "Selected for keeping : " << nCellsToKeep
+        << " cells." << endl;
+
+
+    // Remove cells
+    removeCells cellRemover(mesh_);
+
+    // Pick up patches for exposed faces
+    labelList exposedFaces(cellRemover.getExposedFaces(cellsToRemove));
+    labelList exposedPatches(exposedFaces.size());
+
+    forAll(exposedFaces, i)
+    {
+        label faceI = exposedFaces[i];
+
+        if (ownPatch[faceI] != -1)
+        {
+            exposedPatches[i] = ownPatch[faceI];
+        }
+        else
+        {
+            WarningIn("meshRefinement::splitMesh(..)")
+                << "For exposed face " << faceI
+                << " fc:" << mesh_.faceCentres()[faceI]
+                << " found no patch." << endl
+                << "    Taking patch " << defaultPatch
+                << " instead." << endl;
+            exposedPatches[i] = defaultPatch;
+        }
+    }
+
+    return doRemoveCells
+    (
+        cellsToRemove,
+        exposedFaces,
+        exposedPatches,
+        cellRemover
+    );
+}
+
+
+// Find boundary points that connect to more than one cell region and
+// split them.
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::dupNonManifoldPoints()
+{
+    // Pick all points
+    // - on the outside
+    // - that are used by faces that are not all reachable by single
+    //   cell-face-cell walk
+    indirectPrimitivePatch allOutside
+    (
+        IndirectList<face>
+        (
+            mesh_.faces(),
+            identity
+            (
+                mesh_.nFaces()
+              - mesh_.nInternalFaces()
+            )
+          + mesh_.nInternalFaces()
+        ),
+        mesh_.points()
+    );
+
+
+    // All points on non-manifold regions.
+    labelList nonManifPoints;
+    {
+        pointSet nonManifPointSet
+        (
+            mesh_,
+            "nonManifoldPoints",
+            mesh_.nPoints()/1000
+        );
+
+        forAll(allOutside.meshPoints(), localPointI)
+        {
+            label pointI = allOutside.meshPoints()[localPointI];
+
+            if (!localPointRegion::isSingleCellRegion(mesh_, pointI))
+            {
+                nonManifPointSet.insert(pointI);
+            }
+        }
+
+        // Remove points on coupled boundaries since these are too hard
+        // to handle (and snapping probably goes wrong on them anyway)
+        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+        forAll(patches, patchI)
+        {
+            const polyPatch& pp = patches[patchI];
+
+            if (pp.coupled())
+            {
+                const labelList& meshPoints = pp.meshPoints();
+
+                forAll(meshPoints, i)
+                {
+                    nonManifPointSet.erase(meshPoints[i]);
+                }
+            }
+        }
+
+        if (debug)
+        {
+            Pout<< "Writing " << nonManifPointSet.size()
+                << " non-manif points to " << nonManifPointSet.objectPath()
+                << endl;
+            nonManifPointSet.write();
+        }
+
+
+        label nNonManifPoints = nonManifPointSet.size();
+        reduce(nNonManifPoints, sumOp<label>());
+
+        Info<< "dupNonManifoldPoints : Found : " << nNonManifPoints
+            << " non-manifold points (out of "
+            << mesh_.globalData().nTotalPoints()
+            << ')' << endl;
+
+        nonManifPoints = nonManifPointSet.toc();
+    }
+
+
+    // Topochange container
+    polyTopoChange meshMod(mesh_);
+
+
+//    // Analyse which points need to be duplicated
+//    localPointRegion regionSide(mesh_, nonManifPoints);
+//
+//    Pout<< "dupNonManifoldPoints : Found regions:"
+//        << regionSide.nRegions() << endl;
+//
+//    // Topo change engine
+//    directDuplicatePoints pointDuplicator(mesh_);
+//
+//    pointDuplicator.setRefinement
+//    (
+//        nonManifPoints,
+//        regionSide,
+//        meshMod
+//    );
+
+//DIY replacement of localPointRegion+directDuplicatePoints
+    {
+        labelListList pointFaceRegion(nonManifPoints.size());
+        forAll(nonManifPoints, i)
+        {
+            label pointI = nonManifPoints[i];
+
+            const labelList& pFaces = mesh_.pointFaces()[pointI];
+
+            labelList& pRegions = pointFaceRegion[i];
+            pRegions.setSize(pFaces.size());
+            pRegions = -1;
+
+            // Walk cell face cell on the point
+            label regionI = 0;
+
+            forAll(pRegions, j)
+            {
+                label faceI = pFaces[j];
+
+                label nChanged = localPointRegion::walkCellFaceCell
+                (
+                    mesh_,
+                    mesh_.faceOwner()[faceI],
+                    pointI,
+                    regionI,
+                    pRegions
+                );
+
+                if (nChanged > 0)
+                {
+                    regionI++;
+                }
+            }
+
+            if (regionI <= 1)
+            {
+                FatalErrorIn("dupNonManifoldPoints")
+                    << "Problem pointI:" << pointI
+                    << " pRegions:" << pRegions << " nRegions:" << regionI
+                    << abort(FatalError);
+            }
+        }
+
+        // Do point duplication
+        // ~~~~~~~~~~~~~~~~~~~~
+
+        // Copy of faces
+        faceList newFaces(mesh_.faces());
+
+        // For all points-to-be-duplicated replace occurences of region with
+        // newly added point
+        forAll(nonManifPoints, nonI)
+        {
+            label pointI = nonManifPoints[nonI];
+
+            // Per local region the point to use (original or added)
+            Map<label> regionToPoint;
+
+            // original point gets used for region 0
+            regionToPoint.insert(0, pointI);
+
+            const labelList& pFaces = mesh_.pointFaces()[pointI];
+            const labelList& pRegions = pointFaceRegion[nonI];
+
+            forAll(pFaces, pFaceI)
+            {
+                // Get connected face and its region
+                label faceI = pFaces[pFaceI];
+                label region = pRegions[pFaceI];
+
+                label newPointI = -1;
+
+                Map<label>::const_iterator iter = regionToPoint.find(region);
+
+                if (iter != regionToPoint.end())
+                {
+                    newPointI = iter();
+                }
+                else
+                {
+                    // Add a point for this region
+                    newPointI = meshMod.setAction
+                    (
+                        polyAddPoint
+                        (
+                            mesh_.points()[pointI], // point
+                            pointI,                 // master point
+                            -1,                     // zone for point
+                            true                    // supports a cell
+                        )
+                    );
+
+                    regionToPoint.insert(region, newPointI);
+                }
+
+                // Replace point with newPointI
+                if (newPointI != pointI)
+                {
+                    const face& f = mesh_.faces()[faceI];
+
+                    label fp = findIndex(f, pointI);
+                    newFaces[faceI][fp] = newPointI;
+
+                    // Extra check.
+                    {
+                        labelList indices = findIndices(f, pointI);
+                        if (indices.size() != 1)
+                        {
+                            FatalErrorIn("dupNonManifoldPoints")
+                                << "point:" << pointI
+                                << " coord:" << mesh_.points()[pointI]
+                                << " face:" << faceI << " verts:" << f
+                                << " indices:" << indices
+                                << abort(FatalError);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Modify faces
+        forAll(newFaces, faceI)
+        {
+            if (newFaces[faceI] != mesh_.faces()[faceI])
+            {
+                label own = mesh_.faceOwner()[faceI];
+                label nei = -1;
+                label patchID = -1;
+                if (mesh_.isInternalFace(faceI))
+                {
+                    nei = mesh_.faceNeighbour()[faceI];
+                }
+                else
+                {
+                    patchID = mesh_.boundaryMesh().whichPatch(faceI);
+                }
+
+                // Get current zone info
+                label zoneID = mesh_.faceZones().whichZone(faceI);
+                bool zoneFlip = false;
+                if (zoneID >= 0)
+                {
+                    const faceZone& fZone = mesh_.faceZones()[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                }
+
+                meshMod.setAction
+                (
+                    polyModifyFace
+                    (
+                        newFaces[faceI],        // modified face
+                        faceI,                  // label of face being modified
+                        own,                    // owner
+                        nei,                    // neighbour
+                        false,                  // face flip
+                        patchID,                // patch for face
+                        false,                  // remove from zone
+                        zoneID,                 // zone for face
+                        zoneFlip                // face flip in zone
+                    )
+                );
+            }
+        }
+    }
+//END OF DIY
+
+
+    // Change the mesh (no inflation, parallel sync)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh if in inflation mode
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+    else
+    {
+        // Delete mesh volumes. No other way to do this?
+        mesh_.clearOut();
+    }
+
+    // Update intersections. Is mapping only (no faces created, positions stay
+    // same) so no need to recalculate intersections.
+    updateMesh(map, labelList(0));
+
+    return map;
+}
+
+
+// Zoning
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
+(
+    const point& keepPoint
+)
+{
+    const wordList& cellZoneNames = surfaces_.cellZoneNames();
+    const wordList& faceZoneNames = surfaces_.faceZoneNames();
+
+    labelList namedSurfaces(surfaces_.getNamedSurfaces());
+
+    boolList isNamedSurface(cellZoneNames.size(), false);
+
+    forAll(namedSurfaces, i)
+    {
+        label surfI = namedSurfaces[i];
+
+        isNamedSurface[surfI] = true;
+
+        Info<< "Surface : " << surfaces_[surfI].searchableSurface::name() << nl
+            << "    faceZone : " << faceZoneNames[surfI] << nl
+            << "    cellZone : " << cellZoneNames[surfI] << endl;
+    }
+
+
+    // Add zones to mesh
+
+    labelList surfaceToFaceZone(faceZoneNames.size(), -1);
+    {
+        faceZoneMesh& faceZones = mesh_.faceZones();
+
+        forAll(namedSurfaces, i)
+        {
+            label surfI = namedSurfaces[i];
+
+            label zoneI = faceZones.findZoneID(faceZoneNames[surfI]);
+
+            if (zoneI == -1)
+            {
+                zoneI = faceZones.size();
+                faceZones.setSize(zoneI+1);
+                faceZones.set
+                (
+                    zoneI,
+                    new faceZone
+                    (
+                        faceZoneNames[surfI],   //name
+                        labelList(0),           //addressing
+                        boolList(0),            //flipmap
+                        zoneI,                  //index
+                        faceZones               //faceZoneMesh
+                    )
+                );
+            }
+
+            if (debug)
+            {
+                Pout<< "Faces on " << surfaces_[surfI].searchableSurface::name()
+                    << " will go into faceZone " << zoneI << endl;
+            }
+            surfaceToFaceZone[surfI] = zoneI;
+        }
+
+        // Check they are synced
+        List<wordList> allFaceZones(Pstream::nProcs());
+        allFaceZones[Pstream::myProcNo()] = faceZones.names();
+        Pstream::gatherList(allFaceZones);
+        Pstream::scatterList(allFaceZones);
+
+        for (label procI = 1; procI < allFaceZones.size(); procI++)
+        {
+            if (allFaceZones[procI] != allFaceZones[0])
+            {
+                FatalErrorIn
+                (
+                    "meshRefinement::zonify"
+                    "(const label, const point&)"
+                )   << "Zones not synchronised among processors." << nl
+                    << " Processor0 has faceZones:" << allFaceZones[0]
+                    << " , processor" << procI
+                    << " has faceZones:" << allFaceZones[procI]
+                    << exit(FatalError);
+            }
+        }
+    }
+
+    labelList surfaceToCellZone(cellZoneNames.size(), -1);
+    {
+        cellZoneMesh& cellZones = mesh_.cellZones();
+
+        forAll(namedSurfaces, i)
+        {
+            label surfI = namedSurfaces[i];
+
+            label zoneI = cellZones.findZoneID(cellZoneNames[surfI]);
+
+            if (zoneI == -1)
+            {
+                zoneI = cellZones.size();
+                cellZones.setSize(zoneI+1);
+                cellZones.set
+                (
+                    zoneI,
+                    new cellZone
+                    (
+                        cellZoneNames[surfI],   //name
+                        labelList(0),           //addressing
+                        zoneI,                  //index
+                        cellZones               //cellZoneMesh
+                    )
+                );
+            }
+
+            if (debug)
+            {
+                Pout<< "Cells inside "
+                    << surfaces_[surfI].searchableSurface::name()
+                    << " will go into cellZone " << zoneI << endl;
+            }
+            surfaceToCellZone[surfI] = zoneI;
+        }
+
+        // Check they are synced
+        List<wordList> allCellZones(Pstream::nProcs());
+        allCellZones[Pstream::myProcNo()] = cellZones.names();
+        Pstream::gatherList(allCellZones);
+        Pstream::scatterList(allCellZones);
+
+        for (label procI = 1; procI < allCellZones.size(); procI++)
+        {
+            if (allCellZones[procI] != allCellZones[0])
+            {
+                FatalErrorIn
+                (
+                    "meshRefinement::zonify"
+                    "(const label, const point&)"
+                )   << "Zones not synchronised among processors." << nl
+                    << " Processor0 has cellZones:" << allCellZones[0]
+                    << " , processor" << procI
+                    << " has cellZones:" << allCellZones[procI]
+                    << exit(FatalError);
+            }
+        }
+    }
+
+
+
+    const pointField& cellCentres = mesh_.cellCentres();
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+
+    // Mark faces intersecting zoned surfaces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    // Like surfaceIndex_ but only for named surfaces.
+    labelList namedSurfaceIndex(mesh_.nFaces(), -1);
+
+    {
+        // Statistics: number of faces per faceZone
+        labelList nSurfFaces(faceZoneNames.size(), 0);
+
+        // Swap neighbouring cell centres and cell level
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+        pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+        calcNeighbourData(neiLevel, neiCc);
+
+        // Note: for all internal faces? internal + coupled?
+        // Since zonify is run after baffling the surfaceIndex_ on baffles is
+        // not synchronised across both baffle faces. Fortunately we don't
+        // do zonify baffle faces anyway.
+        forAll(surfaceIndex_, faceI)
+        {
+            label surfI = surfaceIndex_[faceI];
+
+            if
+            (
+                surfI != -1
+             && (
+                    mesh_.isInternalFace(faceI)
+                 || patches[patches.whichPatch(faceI)].coupled()
+                )
+            )
+            {
+                if (isNamedSurface[surfI])
+                {
+                    namedSurfaceIndex[faceI] = surfI;
+                    nSurfFaces[surfI]++;
+                }
+                else
+                {
+                    // Test more accurately for whether intersection is at
+                    // zoneable surface
+
+                    label surface1, surface2;
+                    pointIndexHit hit1, hit2;
+
+                    if (mesh_.isInternalFace(faceI))
+                    {
+                        surfaces_.findNearestIntersection
+                        (
+                            namedSurfaces,
+                            cellCentres[faceOwner[faceI]],
+                            cellCentres[faceNeighbour[faceI]],
+
+                            surface1,
+                            hit1,
+                            surface2,
+                            hit2
+                        );
+                    }
+                    else
+                    {
+                        surfaces_.findNearestIntersection
+                        (
+                            namedSurfaces,
+                            cellCentres[faceOwner[faceI]],
+                            neiCc[faceI-mesh_.nInternalFaces()],
+
+                            surface1,
+                            hit1,
+                            surface2,
+                            hit2
+                        );
+                    }
+
+                    if (hit1.hit())
+                    {
+                        // If both hit should probably choose nearest. For
+                        // later.
+                        namedSurfaceIndex[faceI] = surface1;
+                        nSurfFaces[surface1]++;
+                    }
+                    else if (hit2.hit())
+                    {
+                        namedSurfaceIndex[faceI] = surface2;
+                        nSurfFaces[surface2]++;
+                    }
+                }
+            }
+        }
+
+        // surfaceIndex migh have different surfaces on both sides if
+        // there happen to be a (obviously thin) surface with different
+        // regions between the cell centres. If one is on a named surface
+        // and the other is not this might give problems so sync.
+        syncTools::syncFaceList
+        (
+            mesh_,
+            namedSurfaceIndex,
+            maxEqOp<label>(),
+            false
+        );
+
+        // Print a bit
+        if (debug)
+        {
+            forAll(nSurfFaces, surfI)
+            {
+                Pout<< "Surface:"
+                    << surfaces_[surfI].searchableSurface::name()
+                    << "  nZoneFaces:" << nSurfFaces[surfI] << nl;
+            }
+            Pout<< endl;
+        }
+    }
+
+
+    // Topochange container
+    polyTopoChange meshMod(mesh_);
+
+
+    // Put the faces into the correct zone
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        label surfI = namedSurfaceIndex[faceI];
+
+        if (surfI != -1)
+        {
+            meshMod.setAction
+            (
+                polyModifyFace
+                (
+                    mesh_.faces()[faceI],           // modified face
+                    faceI,                          // label of face
+                    faceOwner[faceI],               // owner
+                    faceNeighbour[faceI],           // neighbour
+                    false,                          // face flip
+                    -1,                             // patch for face
+                    false,                          // remove from zone
+                    surfaceToFaceZone[surfI],       // zone for face
+                    false                           // face flip in zone
+                )
+            );
+        }
+    }
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        label faceI = pp.start();
+
+        forAll(pp, i)
+        {
+            label surfI = namedSurfaceIndex[faceI];
+
+            if (surfI != -1)
+            {
+                meshMod.setAction
+                (
+                    polyModifyFace
+                    (
+                        mesh_.faces()[faceI],           // modified face
+                        faceI,                          // label of face
+                        faceOwner[faceI],              // owner
+                        -1,                             // neighbour
+                        false,                          // face flip
+                        patchI,                         // patch for face
+                        false,                          // remove from zone
+                        surfaceToFaceZone[surfI],       // zone for face
+                        false                           // face flip in zone
+                    )
+                );
+            }
+            faceI++;
+        }
+    }
+
+
+    // Put the cells into the correct zone
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList closedNamedSurfaces(namedSurfaces.size());
+    label nClosed = 0;
+
+    forAll(namedSurfaces, i)
+    {
+        label surfI = namedSurfaces[i];
+
+        if (surfaces_.closed()[surfI])
+        {
+            closedNamedSurfaces[nClosed++] = surfI;
+        }
+    }
+    closedNamedSurfaces.setSize(nClosed);
+
+
+    // Zone per cell:
+    // -2 : unset
+    // -1 : not in any zone
+    // >=0: zoneID
+    labelList cellToZone(mesh_.nCells(), -2);
+
+
+    // Set using geometric test
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    if (closedNamedSurfaces.size() > 0)
+    {
+        findCellZoneGeometric
+        (
+            closedNamedSurfaces,   // indices of closed surfaces
+            namedSurfaceIndex,     // per face index of named surface
+            surfaceToCellZone,     // cell zone index per surface
+            cellToZone
+        );
+    }
+
+
+    // Set using walking
+    // ~~~~~~~~~~~~~~~~~
+
+    //if (returnReduce(nSet, sumOp<label>()) < mesh_.globalData().nTotalCells())
+    {
+        // Topological walk
+        findCellZoneTopo
+        (
+            keepPoint,
+            namedSurfaceIndex,
+            surfaceToCellZone,
+            cellToZone
+        );
+    }
+
+
+    // Actually move the cells to their zone
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(cellToZone, cellI)
+    {
+        label zoneI = cellToZone[cellI];
+
+        if (zoneI >= 0)
+        {
+            meshMod.setAction
+            (
+                polyModifyCell
+                (
+                    cellI,
+                    false,          // removeFromZone
+                    zoneI
+                )
+            );
+        }
+    }
+
+    // Change the mesh (no inflation, parallel sync)
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Move mesh if in inflation mode
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+    else
+    {
+        // Delete mesh volumes. No other way to do this?
+        mesh_.clearOut();
+    }
+
+    return map;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
new file mode 100644
index 0000000000..d5ba7b052f
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
@@ -0,0 +1,230 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    meshRefinement
+
+\*----------------------------------------------------------------------------*/
+
+#include "meshRefinement.H"
+#include "combineFaces.H"
+#include "polyTopoChange.H"
+#include "removePoints.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Merge faces that are in-line.
+Foam::label Foam::meshRefinement::mergePatchFaces
+(
+    const scalar minCos,
+    const scalar concaveCos
+)
+{
+    // Patch face merging engine
+    combineFaces faceCombiner(mesh_);
+
+    // Get all sets of faces that can be merged
+    labelListList mergeSets(faceCombiner.getMergeSets(minCos, concaveCos));
+
+    label nFaceSets = returnReduce(mergeSets.size(), sumOp<label>());
+
+    Info<< "mergePatchFaces : Merging " << nFaceSets
+        << " sets of faces." << endl;
+
+    if (nFaceSets > 0)
+    {
+        // Topology changes container
+        polyTopoChange meshMod(mesh_);
+
+        // Merge all faces of a set into the first face of the set. Remove
+        // unused points.
+        faceCombiner.setRefinement(mergeSets, meshMod);
+
+        // Change the mesh (no inflation)
+        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes. No other way to do this?
+            mesh_.clearOut();
+        }
+
+        faceCombiner.updateMesh(map);
+
+        // Get the kept faces that need to be recalculated.
+        // Merging two boundary faces might shift the cell centre
+        // (unless the faces are absolutely planar)
+        labelHashSet retestFaces(6*mergeSets.size());
+
+        forAll(mergeSets, setI)
+        {
+            label oldMasterI = mergeSets[setI][0];
+
+            label faceI = map().reverseFaceMap()[oldMasterI];
+
+            // faceI is always uncoupled boundary face
+            const cell& cFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+            forAll(cFaces, i)
+            {
+                retestFaces.insert(cFaces[i]);
+            }
+        }
+        updateMesh(map, retestFaces.toc());
+    }
+
+
+    return nFaceSets;
+}
+
+
+// Remove points not used by any face or points used by only two faces where
+// the edges are in line
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeEdges
+(
+    const scalar minCos
+)
+{
+    // Point removal analysis engine
+    removePoints pointRemover(mesh_);
+
+    // Count usage of points
+    boolList pointCanBeDeleted;
+    label nRemove = pointRemover.countPointUsage(minCos, pointCanBeDeleted);
+
+    Info<< "Removing " << nRemove
+        << " straight edge points." << endl;
+
+    autoPtr<mapPolyMesh> map;
+
+    if (nRemove > 0)
+    {
+        // Save my local faces that will change. These changed faces might
+        // cause a shift in the cell centre which needs to be retested.
+        // Have to do this before changing mesh since point will be removed.
+        labelHashSet retestOldFaces(nRemove / Pstream::nProcs());
+
+        {
+            const faceList& faces = mesh_.faces();
+
+            forAll(faces, faceI)
+            {
+                const face& f = faces[faceI];
+
+                forAll(f, fp)
+                {
+                    if (pointCanBeDeleted[f[fp]])
+                    {
+                        retestOldFaces.insert(faceI);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Topology changes container
+        polyTopoChange meshMod(mesh_);
+
+        pointRemover.setRefinement(pointCanBeDeleted, meshMod);
+
+        // Change the mesh (no inflation)
+        map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes. No other way to do this?
+            mesh_.clearOut();
+        }
+
+        pointRemover.updateMesh(map);
+
+        // Get the kept faces that need to be recalculated.
+        labelHashSet retestFaces(6*retestOldFaces.size());
+
+        const cellList& cells = mesh_.cells();
+
+        forAllConstIter(labelHashSet, retestOldFaces, iter)
+        {
+            label faceI = map().reverseFaceMap()[iter.key()];
+
+            const cell& ownFaces = cells[mesh_.faceOwner()[faceI]];
+
+            forAll(ownFaces, i)
+            {
+                retestFaces.insert(ownFaces[i]);
+            }
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                const cell& neiFaces = cells[mesh_.faceNeighbour()[faceI]];
+
+                forAll(neiFaces, i)
+                {
+                    retestFaces.insert(neiFaces[i]);
+                }
+            }
+        }
+        updateMesh(map, retestFaces.toc());
+    }
+
+    return map;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
new file mode 100644
index 0000000000..48f1ba8d9f
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
@@ -0,0 +1,1360 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    meshRefinement
+
+\*----------------------------------------------------------------------------*/
+
+#include "meshRefinement.H"
+#include "trackedParticle.H"
+#include "syncTools.H"
+#include "Time.H"
+#include "refinementSurfaces.H"
+#include "faceSet.H"
+#include "decompositionMethod.H"
+#include "fvMeshDistribute.H"
+#include "polyTopoChange.H"
+#include "mapDistributePolyMesh.H"
+#include "featureEdgeMesh.H"
+#include "Cloud.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Get faces (on the new mesh) that have in some way been affected by the
+// mesh change. Picks up all faces but those that are between two
+// unrefined faces. (Note that of an unchanged face the edge still might be
+// split but that does not change any face centre or cell centre.
+Foam::labelList Foam::meshRefinement::getChangedFaces
+(
+    const mapPolyMesh& map,
+    const labelList& oldCellsToRefine
+)
+{
+    const polyMesh& mesh = map.mesh();
+
+    labelList changedFaces;
+    {
+        // Mark any face on a cell which has been added or changed
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Note that refining a face changes the face centre (for a warped face)
+        // which changes the cell centre. This again changes the cellcentre-
+        // cellcentre edge across all faces of the cell.
+        // Note: this does not happen for unwarped faces but unfortunately
+        // we don't have this information.
+
+        const labelList& faceOwner = mesh.faceOwner();
+        const labelList& faceNeighbour = mesh.faceNeighbour();
+        const cellList& cells = mesh.cells();
+        const label nInternalFaces = mesh.nInternalFaces();
+
+        // Mark refined cells on old mesh
+        PackedList<1> oldRefineCell(map.nOldCells(), 0u);
+
+        forAll(oldCellsToRefine, i)
+        {
+            oldRefineCell.set(oldCellsToRefine[i], 1u);
+        }
+
+        // Mark refined faces
+        PackedList<1> refinedInternalFace(nInternalFaces, 0u);
+
+        // 1. Internal faces
+
+        for (label faceI = 0; faceI < nInternalFaces; faceI++)
+        {
+            label oldOwn = map.cellMap()[faceOwner[faceI]];
+            label oldNei = map.cellMap()[faceNeighbour[faceI]];
+
+            if
+            (
+                oldOwn >= 0
+             && oldRefineCell.get(oldOwn) == 0u
+             && oldNei >= 0
+             && oldRefineCell.get(oldNei) == 0u
+            )
+            {
+                // Unaffected face since both neighbours were not refined.
+            }
+            else
+            {
+                refinedInternalFace.set(faceI, 1u);
+            }
+        }
+
+
+        // 2. Boundary faces
+
+        boolList refinedBoundaryFace(mesh.nFaces()-nInternalFaces, false);
+
+        forAll(mesh.boundaryMesh(), patchI)
+        {
+            const polyPatch& pp = mesh.boundaryMesh()[patchI];
+
+            label faceI = pp.start();
+
+            forAll(pp, i)
+            {
+                label oldOwn = map.cellMap()[faceOwner[faceI]];
+
+                if (oldOwn >= 0 && oldRefineCell.get(oldOwn) == 0u)
+                {
+                    // owner did exist and wasn't refined.
+                }
+                else
+                {
+                    refinedBoundaryFace[faceI-nInternalFaces] = true;
+                }
+                faceI++;
+            }
+        }
+
+        // Synchronise refined face status
+        syncTools::syncBoundaryFaceList
+        (
+            mesh,
+            refinedBoundaryFace,
+            orEqOp<bool>(),
+            false
+        );
+
+
+        // 3. Mark all faces affected by refinement. Refined faces are in
+        //    - refinedInternalFace
+        //    - refinedBoundaryFace
+        boolList changedFace(mesh.nFaces(), false);
+
+        forAll(refinedInternalFace, faceI)
+        {
+            if (refinedInternalFace.get(faceI) == 1u)
+            {
+                const cell& ownFaces = cells[faceOwner[faceI]];
+                forAll(ownFaces, ownI)
+                {
+                    changedFace[ownFaces[ownI]] = true;
+                }
+                const cell& neiFaces = cells[faceNeighbour[faceI]];
+                forAll(neiFaces, neiI)
+                {
+                    changedFace[neiFaces[neiI]] = true;
+                }
+            }
+        }
+
+        forAll(refinedBoundaryFace, i)
+        {
+            if (refinedBoundaryFace[i])
+            {
+                const cell& ownFaces = cells[faceOwner[i+nInternalFaces]];
+                forAll(ownFaces, ownI)
+                {
+                    changedFace[ownFaces[ownI]] = true;
+                }
+            }
+        }
+
+        syncTools::syncFaceList
+        (
+            mesh,
+            changedFace,
+            orEqOp<bool>(),
+            false
+        );
+
+
+        // Now we have in changedFace marked all affected faces. Pack.
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        label nChanged = 0;
+
+        forAll(changedFace, faceI)
+        {
+            if (changedFace[faceI])
+            {
+                nChanged++;
+            }
+        }
+
+        changedFaces.setSize(nChanged);
+        nChanged = 0;
+
+        forAll(changedFace, faceI)
+        {
+            if (changedFace[faceI])
+            {
+                changedFaces[nChanged++] = faceI;
+            }
+        }
+    }
+
+    label nChangedFaces = changedFaces.size();
+    reduce(nChangedFaces, sumOp<label>());
+
+    if (debug)
+    {
+        Pout<< "getChangedFaces : Detected "
+            << " local:" << changedFaces.size()
+            << " global:" << nChangedFaces
+            << " changed faces out of " << mesh.globalData().nTotalFaces()
+            << endl;
+
+        faceSet changedFacesSet(mesh, "changedFaces", changedFaces);
+        Pout<< "getChangedFaces : Writing " << changedFaces.size()
+            << " changed faces to faceSet " << changedFacesSet.name()
+            << endl;
+        changedFacesSet.write();
+    }
+
+    return changedFaces;
+}
+
+
+// Mark cell for refinement (if not already marked). Return false if
+// refinelimit hit. Keeps running count (in nRefine) of cells marked for
+// refinement
+bool Foam::meshRefinement::markForRefine
+(
+    const label markValue,
+    const label nAllowRefine,
+
+    label& cellValue,
+    label& nRefine
+)
+{
+    if (cellValue == -1)
+    {
+        cellValue = markValue;
+        nRefine++;
+    }
+
+    return nRefine <= nAllowRefine;
+}
+
+
+// Calculates list of cells to refine based on intersection with feature edge.
+Foam::label Foam::meshRefinement::markFeatureRefinement
+(
+    const point& keepPoint,
+    const PtrList<featureEdgeMesh>& featureMeshes,
+    const labelList& featureLevels,
+    const label nAllowRefine,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    // We want to refine all cells containing a feature edge.
+    // - don't want to search over whole mesh
+    // - don't want to build octree for whole mesh
+    // - so use tracking to follow the feature edges
+    //
+    // 1. find non-manifold points on feature edges (i.e. start of feature edge
+    //    or 'knot')
+    // 2. seed particle starting at keepPoint going to this non-manifold point
+    // 3. track particles to their non-manifold point
+    //
+    // 4. track particles across their connected feature edges, marking all
+    //    visited cells with their level (through trackingData)
+    // 5. do 4 until all edges have been visited.
+
+
+    // Find all start cells of features. Is done by tracking from keepPoint.
+    Cloud<trackedParticle> cloud(mesh_, IDLList<trackedParticle>());
+
+    // Create particles on whichever processor holds the keepPoint.
+    label cellI = mesh_.findCell(keepPoint);
+
+    if (cellI != -1)
+    {
+        forAll(featureMeshes, featI)
+        {
+            const featureEdgeMesh& featureMesh = featureMeshes[featI];
+            const labelListList& pointEdges = featureMesh.pointEdges();
+
+            forAll(pointEdges, pointI)
+            {
+                if (pointEdges[pointI].size() != 2)
+                {
+                    if (debug)
+                    {
+                        Pout<< "Adding particle from point:" << pointI
+                            << " coord:" << featureMesh.points()[pointI]
+                            << " pEdges:" << pointEdges[pointI]
+                            << endl;
+                    }
+
+                    // Non-manifold point. Create particle.
+                    cloud.addParticle
+                    (
+                        new trackedParticle
+                        (
+                            cloud,
+                            keepPoint,
+                            cellI,
+                            featureMesh.points()[pointI],   // endpos
+                            featureLevels[featI],           // level
+                            featI,                          // featureMesh
+                            pointI                          // end point
+                        )
+                    );
+                }
+            }
+        }
+    }
+
+
+    // Largest refinement level of any feature passed through
+    labelList maxFeatureLevel(mesh_.nCells(), -1);
+
+    // Database to pass into trackedParticle::move
+    trackedParticle::trackData td(cloud, maxFeatureLevel);
+
+    // Track all particles to their end position.
+    cloud.move(td);
+
+    // Reset level
+    maxFeatureLevel = -1;
+
+    // Whether edge has been visited.
+    List<PackedList<1> > featureEdgeVisited(featureMeshes.size());
+
+    forAll(featureMeshes, featI)
+    {
+        featureEdgeVisited[featI].setSize(featureMeshes[featI].edges().size());
+        featureEdgeVisited[featI] = 0u;
+    }
+
+    while (true)
+    {
+        label nParticles = 0;
+
+        // Make particle follow edge.
+        forAllIter(Cloud<trackedParticle>, cloud, iter)
+        {
+            trackedParticle& tp = iter();
+
+            label featI = tp.i();
+            label pointI = tp.j();
+
+            const featureEdgeMesh& featureMesh = featureMeshes[featI];
+            const labelList& pEdges = featureMesh.pointEdges()[pointI];
+
+            // Particle now at pointI. Check connected edges to see which one
+            // we have to visit now.
+
+            bool keepParticle = false;
+
+            forAll(pEdges, i)
+            {
+                label edgeI = pEdges[i];
+
+                if (featureEdgeVisited[featI].get(edgeI) == 0)
+                {
+                    // Unvisited edge. Make the particle go to the other point
+                    // on the edge.
+
+                    const edge& e = featureMesh.edges()[edgeI];
+                    label otherPointI = e.otherVertex(pointI);
+
+                    featureEdgeVisited[featI].set(edgeI, 1u);
+                    tp.end() = featureMesh.points()[otherPointI];
+                    tp.j() = otherPointI;
+                    keepParticle = true;
+                    break;
+                }
+            }
+
+            if (!keepParticle)
+            {
+                // Particle at 'knot' where another particle already has been
+                // seeded. Delete particle.
+                cloud.deleteParticle(tp);
+            }
+            else
+            {
+                // Keep particle
+                nParticles++;
+            }
+        }
+
+        reduce(nParticles, sumOp<label>());
+        if (nParticles == 0)
+        {
+            break;
+        }
+
+        // Track all particles to their end position.
+        cloud.move(td);
+    }
+
+
+    // See which cells to refine. maxFeatureLevel will hold highest level
+    // of any feature edge that passed through.
+
+    const labelList& cellLevel = meshCutter_.cellLevel();
+
+    label oldNRefine = nRefine;
+
+    forAll(maxFeatureLevel, cellI)
+    {
+        if (maxFeatureLevel[cellI] > cellLevel[cellI])
+        {
+            // Mark
+            if
+            (
+               !markForRefine
+                (
+                    0,                      // surface (n/a)
+                    nAllowRefine,
+                    refineCell[cellI],
+                    nRefine
+                )
+            )
+            {
+                // Reached limit
+                break;
+            }
+        }
+    }
+
+    return returnReduce(nRefine-oldNRefine,  sumOp<label>());
+}
+
+
+// Mark cells for non-surface intersection based refinement.
+Foam::label Foam::meshRefinement::markInternalRefinement
+(
+    const PtrList<searchableSurface>& shells,
+    const labelList& shellLevels,
+    const boolList& shellRefineInside,
+    const label nAllowRefine,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const pointField& cellCentres = mesh_.cellCentres();
+
+
+    label oldNRefine = nRefine;
+
+    // Number of cells marked for refinement per shell.
+    labelList nCellsPerShell(shells.size(), 0);
+
+    forAll(cellLevel, cellI)
+    {
+        if (refineCell[cellI] == -1)
+        {
+            // Cell not marked for refinement. Check if inside any shell
+            // with higher refinement level than cell currently has.
+
+            bool reachedLimit = false;
+
+            forAll(shells, shellI)
+            {
+                // Cached inside-outside from tree
+                searchableSurface::volumeType t =
+                    shells[shellI].getVolumeType(cellCentres[cellI]);
+
+                //// Uncached inside-outside from treeData
+                //label t = shells[shellI].shapes().getVolumeType
+                //    (
+                //        shells[shellI],
+                //        cellCentres[cellI]
+                //    );
+
+                // Which side of shell is to be refined
+                searchableSurface::volumeType refSide =
+                (
+                    shellRefineInside[shellI]
+                  ? searchableSurface::INSIDE
+                  : searchableSurface::OUTSIDE
+                );
+
+                if (t == refSide && cellLevel[cellI] < shellLevels[shellI])
+                {
+                    // Cell is inside shell with higher refinement level. Mark
+                    // for refinement.
+
+                    reachedLimit = !markForRefine
+                    (
+                        labelMax,
+                        nAllowRefine,
+                        refineCell[cellI],
+                        nRefine
+                    );
+
+                    if (reachedLimit)
+                    {
+                        if (debug)
+                        {
+                            Pout<< "Stopped refining internal cells"
+                                << " since reaching my cell limit of "
+                                << mesh_.nCells()+7*nRefine << endl;
+                        }
+                        break;
+                    }
+                    else
+                    {
+                        // Cell successfully marked for refinement
+                        nCellsPerShell[shellI]++;
+                    }
+                }
+            }
+
+            if (reachedLimit)
+            {
+                break;
+            }
+        }
+    }
+
+    Pstream::listCombineGather(nCellsPerShell, plusEqOp<label>());
+    Pstream::listCombineScatter(nCellsPerShell);
+
+    Info<< "Marked for refinement per shell :" << endl;
+    forAll(nCellsPerShell, shellI)
+    {
+        Info<< "    shell:" << shellI << " nCells:" << nCellsPerShell[shellI]
+            << nl;
+    }
+
+    return returnReduce(nRefine-oldNRefine, sumOp<label>());
+}
+
+
+// Mark cells for surface intersection based refinement.
+Foam::label Foam::meshRefinement::markSurfaceRefinement
+(
+    const label nAllowRefine,
+    const labelList& neiLevel,
+    const pointField& neiCc,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    label oldNRefine = nRefine;
+
+    // Use cached surfaceIndex_ to detect if any intersection. If so
+    // re-intersect to determine level wanted.
+
+    label faceI;
+    for (faceI = 0; faceI < surfaceIndex_.size(); faceI++)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            label own = mesh_.faceOwner()[faceI];
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                // Test if not both sides already marked for refinement.
+                if (refineCell[own] == -1 || refineCell[nei] == -1)
+                {
+                    pointIndexHit hit;
+                    label surfI = surfaces_.findHigherIntersection
+                    (
+                        cellCentres[own],
+                        cellCentres[nei],
+                        min(cellLevel[own], cellLevel[nei]),
+                        hit
+                    );
+
+                    if (surfI != -1)
+                    {
+                        // Found intersection with surface with higher wanted
+                        // refinement. Mark cell for refining.
+                        // Note: could do optimization here and only refine the
+                        // side of the face the intersection actually goes
+                        // through.
+                        // This would require us though to find all
+                        // intersections
+                        // first instead of now only the first higher one. Also
+                        // would need the exact intersection of face with cc-cc
+                        // connection?
+
+                        label surfaceMinLevel =
+                            surfaces_.minLevelField(surfI)[hit.index()];
+
+                        if (surfaceMinLevel > cellLevel[own])
+                        {
+                            // Owner needs refining
+                            if
+                            (
+                               !markForRefine
+                                (
+                                    surfI,
+                                    nAllowRefine,
+                                    refineCell[own],
+                                    nRefine
+                                )
+                            )
+                            {
+                                break;
+                            }
+                        }
+
+                        if (surfaceMinLevel > cellLevel[nei])
+                        {
+                            // Neighbour needs refining
+                            if
+                            (
+                               !markForRefine
+                                (
+                                    surfI,
+                                    nAllowRefine,
+                                    refineCell[nei],
+                                    nRefine
+                                )
+                            )
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            else if (refineCell[own] != -1)
+            {
+                // boundary face with unmarked owner
+
+                label bFaceI = faceI - mesh_.nInternalFaces();
+
+                pointIndexHit hit;
+                label surfI = surfaces_.findHigherIntersection
+                (
+                    cellCentres[own],
+                    neiCc[bFaceI],
+                    min(cellLevel[own], neiLevel[bFaceI]),
+                    hit
+                );
+
+                if (surfI != -1)
+                {
+                    if
+                    (
+                       !markForRefine
+                        (
+                            surfI,
+                            nAllowRefine,
+                            refineCell[own],
+                            nRefine
+                        )
+                    )
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    if (faceI < surfaceIndex_.size())
+    {
+        if (debug)
+        {
+            Pout<< "Stopped refining since reaching my cell limit of "
+                << mesh_.nCells()+7*nRefine << endl;
+        }
+    }
+
+    return returnReduce(nRefine-oldNRefine, sumOp<label>());
+}
+
+
+// Given intersection of (face of) cell by newSurfI, newTriI, check whether
+// it needs to be refined. Updates maxCellSurf, maxCellTri and
+// refineCell,nRefine if it decides to refine the cell. Returns false
+// if the nRefine limit has been reached, true otherwise.
+bool Foam::meshRefinement::checkCurvature
+(
+    const labelList& globalToPatch,
+    const scalar curvature,
+    const bool markDifferingRegions,
+    const label nAllowRefine,
+
+    const label newSurfI,
+    const label newTriI,
+
+    const label cellI,
+
+    label& maxCellSurfI,
+    label& maxCellTriI,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+
+    if (maxCellSurfI == -1)
+    {
+        // First visit of cell. Store
+        maxCellSurfI = newSurfI;
+        maxCellTriI = newTriI;
+    }
+    else
+    {
+        // Second or more visit.
+        label cellRegion = surfaces_.triangleRegion(maxCellSurfI, maxCellTriI);
+        label newRegion = surfaces_.triangleRegion(newSurfI, newTriI);
+
+        // Update max
+        label maxLevel = surfaces_.maxLevel()[cellRegion];
+
+        if (surfaces_.maxLevel()[newRegion] > maxLevel)
+        {
+            maxCellSurfI = newSurfI;
+            maxCellTriI = newTriI;
+            maxLevel = surfaces_.maxLevel()[newRegion];
+        }
+
+
+        // Check if cell is candidate for refinement
+        if (cellLevel[cellI] < maxLevel)
+        {
+            // Test 1: different regions
+            if (markDifferingRegions && cellRegion != newRegion)
+            {
+                return markForRefine
+                (
+                    globalToPatch[newRegion],   // mark with non-neg number.
+                    nAllowRefine,
+                    refineCell[cellI],
+                    nRefine
+                );
+            }
+
+            // Test 2: different normals
+            const vector& cellN =
+                surfaces_[maxCellSurfI].faceNormals()[maxCellTriI];
+            const vector& newN =
+                surfaces_[newSurfI].faceNormals()[newTriI];
+
+            if ((cellN & newN) < curvature)
+            {
+                return markForRefine
+                (
+                    globalToPatch[newRegion],   // mark with non-neg number.
+                    nAllowRefine,
+                    refineCell[cellI],
+                    nRefine
+                );
+            }
+        }
+    }
+
+    // Did not reach refinement limit.
+    return true;
+}
+
+
+// Mark cells for surface curvature based refinement.
+Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
+(
+    const labelList& globalToPatch,
+    const scalar curvature,
+    const bool markDifferingRegions,
+    const label nAllowRefine,
+    const labelList& neiLevel,
+    const pointField& neiCc,
+
+    labelList& refineCell,
+    label& nRefine
+) const
+{
+    const labelList& cellLevel = meshCutter_.cellLevel();
+    const pointField& cellCentres = mesh_.cellCentres();
+
+    label oldNRefine = nRefine;
+
+    // 1. Any cell on more than one surface gets refined (if its current level
+    // is <= max of the surface max level)
+
+    // 2. Any cell on only one surface with a neighbour on a different surface
+    // gets refined (if its current level etc.)
+
+
+
+    // Index of surface with the max maxLevel and the actual triangle
+    // on the surface. We store these and not e.g. global region so we can get
+    // at:
+    //  - global region
+    //  - global patch
+    //  - face normal
+    labelList cellMaxSurface(mesh_.nCells(), -1);
+    labelList cellMaxTriangle(mesh_.nCells(), -1);
+
+    // 1.
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            label own = mesh_.faceOwner()[faceI];
+
+            // There is an intersection. Do more accurate test to get all
+            // intersections
+            labelList surfaceIndices;
+            List<pointIndexHit> hits;
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                surfaces_.findAllIntersections
+                (
+                    cellCentres[own],
+                    cellCentres[nei],
+                    surfaceIndices,
+                    hits
+                );
+            }
+            else
+            {
+                label bFaceI = faceI - mesh_.nInternalFaces();
+
+                surfaces_.findAllIntersections
+                (
+                    cellCentres[own],
+                    neiCc[bFaceI],
+                    surfaceIndices,
+                    hits
+                );
+            }
+
+
+            // See if intersection adds any new information to the owner or
+            // neighbour cell.
+
+            forAll(surfaceIndices, i)
+            {
+                label surfI = surfaceIndices[i];
+                label triI = hits[i].index();
+
+                checkCurvature
+                (
+                    globalToPatch,
+                    curvature,
+                    markDifferingRegions,
+                    nAllowRefine,
+
+                    surfI,
+                    triI,
+
+                    own,
+
+                    cellMaxSurface[own],
+                    cellMaxTriangle[own],
+
+                    refineCell,
+                    nRefine
+                );
+
+                if (mesh_.isInternalFace(faceI))
+                {
+                    label nei = mesh_.faceNeighbour()[faceI];
+
+                    checkCurvature
+                    (
+                        globalToPatch,
+                        curvature,
+                        markDifferingRegions,
+                        nAllowRefine,
+
+                        surfI,
+                        triI,
+
+                        nei,
+
+                        cellMaxSurface[nei],
+                        cellMaxTriangle[nei],
+
+                        refineCell,
+                        nRefine
+                    );
+                }
+            }
+        }
+
+        if (nRefine > nAllowRefine)
+        {
+            if (debug)
+            {
+                Pout<< "Stopped refining since reaching my cell limit of "
+                    << mesh_.nCells()+7*nRefine << endl;
+            }
+            break;
+        }
+    }
+
+    // 2. Find out a measure of surface curvature and region edges.
+    // Send over surface region and surface normal to neighbour cell.
+
+    // global region
+    labelList ownRegion(mesh_.nFaces(), -1);
+    labelList neiRegion(mesh_.nFaces(), -1);
+    // local normal at hit
+    vectorField ownNormal(mesh_.nFaces(), vector::zero);
+    vectorField neiNormal(mesh_.nFaces(), vector::zero);
+
+    // Internal faces
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        label own = mesh_.faceOwner()[faceI];
+
+        if (cellMaxSurface[own] != -1)
+        {
+            label surfI = cellMaxSurface[own];
+            label triI = cellMaxTriangle[own];
+
+            ownRegion[faceI] = surfaces_.triangleRegion(surfI, triI);
+            ownNormal[faceI] = surfaces_[surfI].faceNormals()[triI];
+        }
+
+        label nei = mesh_.faceNeighbour()[faceI];
+
+        if (cellMaxSurface[nei] != -1)
+        {
+            label surfI = cellMaxSurface[nei];
+            label triI = cellMaxTriangle[nei];
+
+            neiRegion[faceI] = surfaces_.triangleRegion(surfI, triI);
+            neiNormal[faceI] = surfaces_[surfI].faceNormals()[triI];
+        }
+    }
+    // Boundary faces
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        label own = mesh_.faceOwner()[faceI];
+
+        if (cellMaxSurface[own] != -1)
+        {
+            label surfI = cellMaxSurface[own];
+            label triI = cellMaxTriangle[own];
+
+            ownRegion[faceI] = surfaces_.triangleRegion(surfI, triI);
+            ownNormal[faceI] = surfaces_[surfI].faceNormals()[triI];
+
+            neiRegion[faceI] = ownRegion[faceI];
+            neiNormal[faceI] = ownNormal[faceI];
+        }
+    }
+
+    syncTools::swapFaceList(mesh_, neiRegion, false);
+    syncTools::swapFaceList(mesh_, neiNormal, false);
+
+    for (label faceI = 0; faceI < mesh_.nFaces(); faceI++)
+    {
+        if (ownRegion[faceI] != -1 && neiRegion[faceI] != -1)
+        {
+            if
+            (
+                (markDifferingRegions && (ownRegion[faceI] != neiRegion[faceI]))
+             || ((ownNormal[faceI] & neiNormal[faceI]) < curvature)
+            )
+            {
+                label own = mesh_.faceOwner()[faceI];
+
+                if (cellLevel[own] < surfaces_.maxLevel()[ownRegion[faceI]])
+                {
+                    if
+                    (
+                        !markForRefine
+                        (
+                            globalToPatch[ownRegion[faceI]],
+                            nAllowRefine,
+                            refineCell[own],
+                            nRefine
+                        )
+                    )
+                    {
+                        if (debug)
+                        {
+                            Pout<< "Stopped refining since reaching my cell"
+                                << " limit of " << mesh_.nCells()+7*nRefine
+                                << endl;
+                        }
+                        break;
+                    }
+
+                }
+
+                if (mesh_.isInternalFace(faceI))
+                {
+                    label nei = mesh_.faceNeighbour()[faceI];
+
+                    if (cellLevel[nei] < surfaces_.maxLevel()[neiRegion[faceI]])
+                    {
+                        if
+                        (
+                            !markForRefine
+                            (
+                                globalToPatch[neiRegion[faceI]],
+                                nAllowRefine,
+
+                                refineCell[nei],
+                                nRefine
+                            )
+                        )
+                        {
+                            if (debug)
+                            {
+                                Pout<< "Stopped refining since reaching my cell"
+                                    << " limit of " << mesh_.nCells()+7*nRefine
+                                    << endl;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    return returnReduce(nRefine-oldNRefine, sumOp<label>());
+    label totNRefined = returnReduce(totNRefined, sumOp<label>());
+
+    return totNRefined;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Calculate list of cells to refine. Gets for any edge (start - end)
+// whether it intersects the surface. Does more accurate test and checks
+// the wanted level on the surface intersected.
+// Does approximate precalculation of how many cells can be refined before
+// hitting overall limit maxGlobalCells.
+Foam::labelList Foam::meshRefinement::refineCandidates
+(
+    const point& keepPoint,
+    const labelList& globalToPatch,
+    const scalar curvature,
+
+    const PtrList<featureEdgeMesh>& featureMeshes,
+    const labelList& featureLevels,
+
+    const PtrList<searchableSurface>& shells,
+    const labelList& shellLevels,
+    const boolList& shellRefineInside,
+
+    const bool featureRefinement,
+    const bool internalRefinement,
+    const bool surfaceRefinement,
+    const bool curvatureRefinement,
+    const label maxGlobalCells,
+    const label maxLocalCells
+) const
+{
+    label totNCells = mesh_.globalData().nTotalCells();
+
+    labelList cellsToRefine;
+
+    if (totNCells < maxGlobalCells)
+    {
+        // Every cell I refine adds 7 cells. Estimate the number of cells
+        // I am allowed to refine.
+        // Assume perfect distribution so can only refine as much the fraction
+        // of the mesh I hold. This prediction step prevents us having to do
+        // lots of reduces to keep count of the total number of cells selected
+        // for refinement.
+
+        //scalar fraction = scalar(mesh_.nCells())/totNCells;
+        //label myMaxCells = label(maxGlobalCells*fraction);
+        //label nAllowRefine = (myMaxCells - mesh_.nCells())/7;
+        ////label nAllowRefine = (maxLocalCells - mesh_.nCells())/7;
+        //
+        //Pout<< "refineCandidates:" << nl
+        //    << "    total cells:" << totNCells << nl
+        //    << "    local cells:" << mesh_.nCells() << nl
+        //    << "    local fraction:" << fraction << nl
+        //    << "    local allowable cells:" << myMaxCells << nl
+        //    << "    local allowable refinement:" << nAllowRefine << nl
+        //    << endl;
+
+        //- Disable refinement shortcut
+        label nAllowRefine = labelMax;
+
+        // Marked for refinement (>= 0) or not (-1). Actual value is the
+        // index of the surface it intersects.
+        labelList refineCell(mesh_.nCells(), -1);
+        label nRefine = 0;
+
+
+        // Swap neighbouring cell centres and cell level
+        labelList neiLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+        pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
+        calcNeighbourData(neiLevel, neiCc);
+
+
+
+        // Cells pierced by feature lines
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        if (featureRefinement)
+        {
+            label nFeatures = markFeatureRefinement
+            (
+                keepPoint,
+                featureMeshes,
+                featureLevels,
+                nAllowRefine,
+
+                refineCell,
+                nRefine
+            );
+
+            Info<< "Marked for refinement due to explicit features    : "
+                << nFeatures << " cells."  << endl;
+        }
+
+        // Inside refinement shells
+        // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+        if (internalRefinement)
+        {
+            label nShell = markInternalRefinement
+            (
+                shells,
+                shellLevels,
+                shellRefineInside,
+                nAllowRefine,
+
+                refineCell,
+                nRefine
+            );
+            Info<< "Marked for refinement due to refinement shells    : "
+                << nShell << " cells."  << endl;
+        }
+
+        // Refinement based on intersection of surface
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        if (surfaceRefinement)
+        {
+            label nSurf = markSurfaceRefinement
+            (
+                nAllowRefine,
+                neiLevel,
+                neiCc,
+
+                refineCell,
+                nRefine
+            );
+            Info<< "Marked for refinement due to surface intersection : "
+                << nSurf << " cells."  << endl;
+        }
+
+        // Refinement based on curvature of surface
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        if (curvatureRefinement)
+        {
+            label nCurv = markSurfaceCurvatureRefinement
+            (
+                globalToPatch,
+                curvature,
+                false,              // do not refine at multiple regions
+                nAllowRefine,
+                neiLevel,
+                neiCc,
+
+                refineCell,
+                nRefine
+            );
+            Info<< "Marked for refinement due to curvature/regions    : "
+                << nCurv << " cells."  << endl;
+        }
+
+        // Pack cells-to-refine
+        // ~~~~~~~~~~~~~~~~~~~~
+
+        cellsToRefine.setSize(nRefine);
+        nRefine = 0;
+
+        forAll(refineCell, cellI)
+        {
+            if (refineCell[cellI] != -1)
+            {
+                cellsToRefine[nRefine++] = cellI;
+            }
+        }
+    }
+
+    return cellsToRefine;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::refine
+(
+    const labelList& cellsToRefine
+)
+{
+    // Mesh changing engine.
+    polyTopoChange meshMod(mesh_);
+
+    // Play refinement commands into mesh changer.
+    meshCutter_.setRefinement(cellsToRefine, meshMod);
+
+    // Create mesh (no inflation), return map from old to new mesh.
+    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false);
+
+    // Update fields
+    mesh_.updateMesh(map);
+
+    // Optionally inflate mesh
+    if (map().hasMotionPoints())
+    {
+        mesh_.movePoints(map().preMotionPoints());
+    }
+
+    // Update intersection info
+    updateMesh(map, getChangedFaces(map, cellsToRefine));
+
+    return map;
+}
+
+
+// Do refinement of consistent set of cells followed by truncation and
+// load balancing.
+Foam::autoPtr<Foam::mapDistributePolyMesh>
+ Foam::meshRefinement::refineAndBalance
+(
+    const string& msg,
+    decompositionMethod& decomposer,
+    fvMeshDistribute& distributor,
+    const labelList& cellsToRefine
+)
+{
+    // Do all refinement
+    refine(cellsToRefine);
+
+    if (debug)
+    {
+        Pout<< "Writing refined but unbalanced " << msg
+            << " mesh to time " << mesh_.time().timeName() << endl;
+        write
+        (
+            debug,
+            mesh_.time().path()
+           /mesh_.time().timeName()
+        );
+        Pout<< "Dumped debug data in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        // test all is still synced across proc patches
+        checkData();
+    }
+
+    Info<< "Refined mesh in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    printMeshInfo(debug, "After refinement " + msg);
+
+
+    //// Remove cells which are inside closed surfaces
+    //// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    //
+    //if (findIndex(surfaces.closed(), true) != -1)
+    //{
+    //    Info<< "Removing cells fully inside closed surfaces."
+    //        << endl;
+    //    removeInsideCells
+    //    (
+    //        msg,               // refinement iteration for statistics only
+    //        exposedFacesPatch  // patch to use for exposed internal faces
+    //    );
+    //    Info<< "Removed inside cells in = "
+    //        << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    //    if (debug)
+    //    {
+    //       // test all is still synced across proc patches
+    //       checkData();
+    //    }
+    //}
+
+
+    // Load balancing
+    // ~~~~~~~~~~~~~~
+
+    autoPtr<mapDistributePolyMesh> distMap;
+
+    if (Pstream::nProcs() > 1)
+    {
+        labelList distribution(decomposer.decompose(mesh_.cellCentres()));
+        // Get distribution such that baffle faces stay internal to the
+        // processor.
+        //labelList distribution(decomposePreserveBaffles(decomposer));
+
+        if (debug)
+        {
+            Pout<< "Wanted distribution:"
+                << distributor.countCells(distribution)
+                << endl;
+        }
+        // Do actual sending/receiving of mesh
+        distMap = distributor.distribute(distribution);
+
+        // Update numbering of meshRefiner
+        distribute(distMap);
+
+        Info<< "Balanced mesh in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+        printMeshInfo(debug, "After balancing " + msg);
+
+
+        if (debug)
+        {
+            Pout<< "Writing " << msg
+                << " mesh to time " << mesh_.time().timeName() << endl;
+            write
+            (
+                debug,
+                mesh_.time().path()
+               /mesh_.time().timeName()
+            );
+            Pout<< "Dumped debug data in = "
+                << mesh_.time().cpuTimeIncrement() << " s" << endl;
+
+            // test all is still synced across proc patches
+            checkData();
+        }
+    }
+
+    return distMap;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementTemplates.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementTemplates.C
new file mode 100644
index 0000000000..1e9b213988
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementTemplates.C
@@ -0,0 +1,195 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "meshRefinement.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Add a T entry
+template<class T> void meshRefinement::updateList
+(
+    const labelList& newToOld,
+    const T& nullValue,
+    List<T>& elems
+)
+{
+    List<T> newElems(newToOld.size(), nullValue);
+
+    forAll(newElems, i)
+    {
+        label oldI = newToOld[i];
+
+        if (oldI >= 0)
+        {
+            newElems[i] = elems[oldI];
+        }
+    }
+
+    elems.transfer(newElems);
+}
+
+
+// Compare two lists over all boundary faces
+template<class T>
+void meshRefinement::testSyncBoundaryFaceList
+(
+    const scalar tol,
+    const string& msg,
+    const UList<T>& faceData,
+    const UList<T>& syncedFaceData
+) const
+{
+    label nBFaces = mesh_.nFaces() - mesh_.nInternalFaces();
+
+    if (faceData.size() != nBFaces || syncedFaceData.size() != nBFaces)
+    {
+        FatalErrorIn
+        (
+            "meshRefinement::testSyncBoundaryFaceList"
+            "(const scalar, const string&, const List<T>&, const List<T>&)"
+        )   << "Boundary faces:" << nBFaces
+            << " faceData:" << faceData.size()
+            << " syncedFaceData:" << syncedFaceData.size()
+            << abort(FatalError);
+    }
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        label bFaceI = pp.start() - mesh_.nInternalFaces();
+
+        forAll(pp, i)
+        {
+            const T& data = faceData[bFaceI];
+            const T& syncData = syncedFaceData[bFaceI];
+
+            if (mag(data - syncData) > tol)
+            {
+                label faceI = pp.start()+i;
+
+                FatalErrorIn("testSyncFaces")
+                    << msg
+                    << "patchFace:" << i
+                    << " face:" << faceI
+                    << " fc:" << mesh_.faceCentres()[faceI]
+                    << " patch:" << pp.name()
+                    << " faceData:" << data
+                    << " syncedFaceData:" << syncData
+                    << " diff:" << mag(data - syncData)
+                    << abort(FatalError);
+            }
+
+            bFaceI++;
+        }
+    }
+}
+
+
+//template <class T, class Mesh>
+template<class GeoField>
+void meshRefinement::addPatchFields(fvMesh& mesh, const word& patchFieldType)
+{
+    HashTable<const GeoField*> flds
+    (
+        mesh.objectRegistry::lookupClass<GeoField>()
+    );
+
+    for
+    (
+        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
+        iter != flds.end();
+        ++iter
+    )
+    {
+        const GeoField& fld = *iter();
+
+        typename GeoField::GeometricBoundaryField& bfld =
+            const_cast<typename GeoField::GeometricBoundaryField&>
+            (
+                fld.boundaryField()
+            );
+
+        label sz = bfld.size();
+        bfld.setSize(sz+1);
+        bfld.set
+        (
+            sz,
+            GeoField::PatchFieldType::New
+            (
+                patchFieldType,
+                mesh.boundary()[sz],
+                fld.dimensionedInternalField()
+            )
+        );
+    }
+}
+
+
+// Reorder patch field
+template<class GeoField>
+void meshRefinement::reorderPatchFields(fvMesh& mesh, const labelList& oldToNew)
+{
+    HashTable<const GeoField*> flds
+    (
+        mesh.objectRegistry::lookupClass<GeoField>()
+    );
+
+    for
+    (
+        typename HashTable<const GeoField*>::const_iterator iter = flds.begin();
+        iter != flds.end();
+        ++iter
+    )
+    {
+        const GeoField& fld = *iter();
+
+        typename GeoField::GeometricBoundaryField& bfld =
+            const_cast<typename GeoField::GeometricBoundaryField&>
+            (
+                fld.boundaryField()
+            );
+
+        bfld.reorder(oldToNew);
+    }
+}
+
+
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.C b/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.C
new file mode 100644
index 0000000000..0c63d4398f
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.C
@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "offsetTriSurfaceMesh.H"
+#include "Random.H"
+#include "addToRunTimeSelectionTable.H"
+#include "triSurfaceTools.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(offsetTriSurfaceMesh, 0);
+addToRunTimeSelectionTable(searchableSurface, offsetTriSurfaceMesh, dict);
+
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::offsetTriSurfaceMesh::offsetTriSurfaceMesh
+(
+    const IOobject& io,
+    const triSurface& s,
+    const scalar offset)
+:
+    triSurfaceMesh(io, s),
+    offset_(offset)
+{}
+
+
+Foam::offsetTriSurfaceMesh::offsetTriSurfaceMesh
+(
+    const IOobject& io,
+    const scalar offset
+)
+:
+    triSurfaceMesh(io),
+    offset_(offset)
+{}
+
+
+Foam::offsetTriSurfaceMesh::offsetTriSurfaceMesh
+(
+    const word& name,
+    const objectRegistry& obj,
+    const dictionary& dict
+)
+:
+    triSurfaceMesh(name, obj, dict),
+    offset_(readScalar(dict.lookup("offset")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::offsetTriSurfaceMesh::~offsetTriSurfaceMesh()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::pointIndexHit Foam::offsetTriSurfaceMesh::findNearest
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    // Find nearest (add offset to search span)
+    pointIndexHit surfNearest = triSurfaceMesh::findNearest
+    (
+        sample,
+        nearestDistSqr + Foam::sqr(offset_)
+    );
+
+    // Shift back onto surface
+    if (surfNearest.hit())
+    {
+        vector n(sample-surfNearest.hitPoint());
+        n /= mag(n)+VSMALL;
+        surfNearest.setPoint(surfNearest.hitPoint() + offset_*n);
+    }
+    return surfNearest;
+}
+
+
+Foam::pointIndexHit Foam::offsetTriSurfaceMesh::findNearestOnEdge
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    // Find nearest (add offset to search span)
+    pointIndexHit surfNearest = triSurfaceMesh::findNearestOnEdge
+    (
+        sample,
+        nearestDistSqr + Foam::sqr(offset_)
+    );
+
+    // Shift back onto surface
+    if (surfNearest.hit())
+    {
+        vector n = sample-surfNearest.hitPoint();
+        n /= mag(n)+VSMALL;
+        surfNearest.setPoint(surfNearest.hitPoint() + offset_*n);
+    }
+    return surfNearest;
+}
+
+
+Foam::searchableSurface::volumeType Foam::offsetTriSurfaceMesh::getVolumeType
+(
+    const point& sample
+) const
+{
+    // Find the nearest point on background surface
+    pointIndexHit surfNearest = triSurfaceMesh::findNearest
+    (
+        sample,
+        Foam::sqr(GREAT)
+    );
+
+    if (!surfNearest.hit())
+    {
+        FatalErrorIn("offsetTriSurfaceMesh::getVolumeType(const point&)")
+            << "treeBb:" << tree().bb()
+            << " sample:" << sample
+            << " surfNearest:" << surfNearest
+            << abort(FatalError);
+    }
+
+    // Offset sample to the point.
+    vector n(surfNearest.hitPoint()-sample);
+    n /= mag(n)+VSMALL;
+
+    triSurfaceTools::sideType t = triSurfaceTools::surfaceSide
+    (
+        *this,
+        sample+offset_*n,
+        surfNearest.index(),
+        surfNearest.hitPoint()
+    );
+
+    if (t == triSurfaceTools::UNKNOWN)
+    {
+        return searchableSurface::UNKNOWN;
+    }
+    else if (t == triSurfaceTools::INSIDE)
+    {
+        return searchableSurface::INSIDE;
+    }
+    else if (t == triSurfaceTools::OUTSIDE)
+    {
+        return searchableSurface::OUTSIDE;
+    }
+    else
+    {
+        FatalErrorIn("offsetTriSurfaceMesh::getVolumeType(const point&)")
+            << "problem" << abort(FatalError);
+        return searchableSurface::UNKNOWN;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.H b/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.H
new file mode 100644
index 0000000000..9e9add77f6
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/offsetTriSurfaceMesh/offsetTriSurfaceMesh.H
@@ -0,0 +1,167 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    offsetTriSurfaceMesh
+
+Description
+    triSurfaceMesh with offset. Used to define refinement boxes as a region
+    within certain distance to the refinement surface.
+    Note: reloads surface.
+
+SourceFiles
+    offsetTriSurfaceMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef offsetTriSurfaceMesh_H
+#define offsetTriSurfaceMesh_H
+
+#include "triSurfaceMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class offsetTriSurfaceMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class offsetTriSurfaceMesh
+:
+    public triSurfaceMesh
+{
+    // Private data
+
+        const scalar offset_;
+
+public:
+
+    //- Runtime type information
+    TypeName("offsetTriSurfaceMesh");
+
+
+    // Constructors
+
+        //- Construct from triSurface and offset
+        offsetTriSurfaceMesh(const IOobject&, const triSurface&, const scalar);
+
+        //- Construct read and offset
+        offsetTriSurfaceMesh(const IOobject& io, const scalar);
+
+        //- Construct as searchableSurface
+        offsetTriSurfaceMesh
+        (
+            const word& name,
+            const objectRegistry& obj,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~offsetTriSurfaceMesh();
+
+
+    // Member Functions
+
+        // searchableSurface implementation
+
+            //- Calculate nearest point on surface. Returns
+            //  - bool : any point found nearer than nearestDistSqr
+            //  - label: relevant index in surface
+            //  - point: actual nearest point found
+            virtual pointIndexHit findNearest
+            (
+                const point& sample,
+                const scalar nearestDistSqr
+            ) const;
+
+            //- Calculate nearest point on edge. Returns
+            //  - bool : any point found nearer than nearestDistSqr
+            //  - label: relevant index in surface
+            //  - point: actual nearest point found
+            virtual pointIndexHit findNearestOnEdge
+            (
+                const point& sample,
+                const scalar nearestDistSqr
+            ) const;
+
+            //- Find nearest to line. Returns
+            //  - bool : any point found?
+            //  - label: relevant index in shapes
+            //  - point: actual nearest point found
+            //  sets:
+            //  - tightest  : bounding box
+            //  - linePoint : corresponding nearest point on line
+            virtual pointIndexHit findNearest
+            (
+                const linePointRef& ln,
+                treeBoundBox& tightest,
+                point& linePoint
+            ) const
+            {
+                notImplemented("offsetTriSurfaceMesh::findNearest(..)");
+                return pointIndexHit();
+            }
+
+            //- Find nearest intersection of line between start and end.
+            virtual pointIndexHit findLine
+            (
+                const point& start,
+                const point& end
+            ) const
+            {
+                notImplemented("offsetTriSurfaceMesh::findLine(..)");
+                return pointIndexHit();
+            }
+
+            //- Find any intersection of line between start and end.
+            virtual pointIndexHit findLineAny
+            (
+                const point& start,
+                const point& end
+            ) const
+            {
+                notImplemented("offsetTriSurfaceMesh::findLine(..)");
+                return pointIndexHit();
+            }
+
+            //- Determine type (inside/outside/mixed) for point. unknown if
+            //  cannot be determined (e.g. non-manifold surface)
+            virtual volumeType getVolumeType(const point&) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
new file mode 100644
index 0000000000..2ab52e0c4e
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
@@ -0,0 +1,503 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    refinementSurfaces
+
+\*----------------------------------------------------------------------------*/
+
+#include "refinementSurfaces.H"
+#include "orientedSurface.H"
+#include "Time.H"
+#include "searchableSurface.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::fileNameList Foam::refinementSurfaces::extractFileNames
+(
+    const PtrList<dictionary>& surfaceDicts
+)
+{
+    fileNameList surfaceFileNames(surfaceDicts.size());
+
+    forAll(surfaceDicts, i)
+    {
+        surfaceFileNames[i] = fileName(surfaceDicts[i].lookup("file"));
+    }
+    return surfaceFileNames;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+Foam::refinementSurfaces::refinementSurfaces
+(
+    const IOobject& io,
+    const PtrList<dictionary>& surfaceDicts
+)
+:
+    triSurfaceMeshes(io, extractFileNames(surfaceDicts)),
+    names_(surfaceDicts.size()),
+    closed_(surfaceDicts.size(), true),
+    faceZoneNames_(surfaceDicts.size()),
+    cellZoneNames_(surfaceDicts.size()),
+    zoneInside_(surfaceDicts.size()),
+    regionOffset_(surfaceDicts.size())
+{
+    labelList globalMinLevel(surfaceDicts.size(), 0);
+    labelList globalMaxLevel(surfaceDicts.size(), 0);
+    List<HashTable<label> > regionMinLevel(surfaceDicts.size());
+    List<HashTable<label> > regionMaxLevel(surfaceDicts.size());
+
+    forAll(surfaceDicts, i)
+    {
+        const dictionary& dict = surfaceDicts[i];
+
+        names_[i] = word(dict.lookup("name"));
+
+        globalMinLevel[i] = readLabel(dict.lookup("minRefinementLevel"));
+        globalMaxLevel[i] = readLabel(dict.lookup("maxRefinementLevel"));
+
+        if
+        (
+            globalMinLevel[i] < 0
+         || globalMaxLevel[i] < globalMinLevel[i]
+        )
+        {
+            FatalErrorIn
+            (
+                "refinementSurfaces::refinementSurfaces"
+                "(const IOobject&, const PtrList<dictionary>&)"
+            )   << "Illegal level specification for surface " << names_[i]
+                << " : minLevel:" << globalMinLevel[i]
+                << " maxLevel:" << globalMaxLevel[i]
+                << exit(FatalError);
+        }
+
+        if (dict.found("faceZone"))
+        {
+            dict.lookup("faceZone") >> faceZoneNames_[i];
+            dict.lookup("cellZone") >> cellZoneNames_[i];
+            dict.lookup("zoneInside") >> zoneInside_[i];
+        }
+
+        if (dict.found("regions"))
+        {
+            PtrList<dictionary> regionDicts(dict.lookup("regions"));
+
+            forAll(regionDicts, dictI)
+            {
+                const dictionary& regionDict = regionDicts[dictI];
+
+                const word regionName(regionDict.lookup("name"));
+                label min = readLabel(regionDict.lookup("minRefinementLevel"));
+                label max = readLabel(regionDict.lookup("maxRefinementLevel"));
+
+                regionMinLevel[i].insert(regionName, min);
+                regionMaxLevel[i].insert(regionName, max);
+            }
+        }
+    }
+
+    // Calculate closedness
+    forAll(closed_, surfI)
+    {
+        const triSurface& s = operator[](surfI);
+
+        const labelListList& edgeFaces = s.edgeFaces();
+
+        forAll(edgeFaces, edgeI)
+        {
+            if (edgeFaces[edgeI].size() != 2)
+            {
+                closed_[surfI] = false;
+                break;
+            }
+        }
+    }
+
+
+    // Calculate local to global region offset
+    label nRegions = 0;
+
+    forAll(surfaceDicts, surfI)
+    {
+        regionOffset_[surfI] = nRegions;
+
+        nRegions += operator[](surfI).patches().size();
+    }
+
+    // From global region number to refinement level
+    minLevel_.setSize(nRegions);
+    minLevel_ = 0;
+    maxLevel_.setSize(nRegions);
+    maxLevel_ = 0;
+
+    forAll(surfaceDicts, surfI)
+    {
+        const geometricSurfacePatchList& regions = operator[](surfI).patches();
+
+        forAll(regions, i)
+        {
+            minLevel_[regionOffset_[surfI] + i] = globalMinLevel[surfI];
+            maxLevel_[regionOffset_[surfI] + i] = globalMaxLevel[surfI];
+        }
+
+        forAllConstIter(HashTable<label>, regionMinLevel[surfI], iter)
+        {
+            // Find the patch
+            forAll(regions, regionI)
+            {
+                if (regions[regionI].name() == iter.key())
+                {
+                    label globalRegionI = regionOffset_[surfI] + regionI;
+
+                    minLevel_[globalRegionI] = iter();
+                    maxLevel_[globalRegionI] =
+                        regionMaxLevel[surfI][iter.key()];
+                    break;
+                }
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Get indices of named surfaces (surfaces with cellZoneNam)
+Foam::labelList Foam::refinementSurfaces::getNamedSurfaces() const
+{
+   labelList namedSurfaces(cellZoneNames_.size());
+
+    label namedI = 0;
+    forAll(cellZoneNames_, surfI)
+    {
+        if (cellZoneNames_[surfI].size() > 0)
+        {
+            namedSurfaces[namedI++] = surfI;
+        }
+    }
+    namedSurfaces.setSize(namedI);
+
+    return namedSurfaces;
+}
+
+
+bool Foam::refinementSurfaces::isSurfaceClosed(const triSurface& s)
+{
+    if (s.nEdges() == s.nInternalEdges())
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Orient surface (if they're closed) before any searching is done.
+void Foam::refinementSurfaces::orientSurface
+(
+    const point& keepPoint,
+    triSurfaceMesh& s
+)
+{
+    // Flip surface so keepPoint is outside.
+    bool anyFlipped = orientedSurface::orient(s, keepPoint, true);
+
+    if (anyFlipped)
+    {
+        // orientedSurface will have done a clearOut of the surface.
+        // we could do a clearout of the triSurfaceMeshes::trees()
+        // but these aren't affected by orientation (except for cached
+        // sideness which should not be set at this point. !!Should
+        // check!)
+
+        Info<< "orientSurfaces : Flipped orientation of surface "
+            << s.searchableSurface::name()
+            << " so point " << keepPoint << " is outside." << endl;
+    }
+}
+
+
+// Count number of triangles per surface region
+Foam::labelList Foam::refinementSurfaces::countRegions(const triSurface& s)
+{
+    const geometricSurfacePatchList& regions = s.patches();
+
+    labelList nTris(regions.size(), 0);
+
+    forAll(s, triI)
+    {
+        nTris[s[triI].region()]++;
+    }
+    return nTris;
+}
+
+
+// Find intersections of edge. Return -1 or first surface with higher minLevel
+// number.
+Foam::label Foam::refinementSurfaces::findHigherIntersection
+(
+    const point& start,
+    const point& end,
+    const label currentLevel,   // current cell refinement level
+
+    pointIndexHit& hit
+) const
+{
+    forAll(*this, surfI)
+    {
+        hit = operator[](surfI).findLineAny(start, end);
+
+        if (hit.hit())
+        {
+            if (currentLevel == -1)
+            {
+                // Return any.
+                return surfI;
+            }
+            else
+            {
+                //const triSurface& s = trees()[surfI].shapes().surface();
+                //label region = globalRegion(surfI, s[hit.index()].region());
+                //if (minLevel_[region] > currentLevel)
+                if (minLevelFields_[surfI][hit.index()] > currentLevel)
+                {
+                    return surfI;
+                }
+            }
+        }
+    }
+
+    hit.setMiss();
+
+    return -1;
+}
+
+
+// Find intersection with max of edge. Return -1 or the surface
+// with the highest maxLevel above currentLevel
+Foam::label Foam::refinementSurfaces::findHighestIntersection
+(
+    const point& start,
+    const point& end,
+    const label currentLevel,   // current cell refinement level
+
+    pointIndexHit& maxHit
+) const
+{
+    // surface with highest maxlevel
+    label maxSurface = -1;
+    // maxLevel of maxSurface
+    label maxLevel = currentLevel;
+
+    forAll(*this, surfI)
+    {
+        pointIndexHit hit = operator[](surfI).findLineAny(start, end);
+
+        if (hit.hit())
+        {
+            const triSurface& s = operator[](surfI);
+
+            label region = globalRegion(surfI, s[hit.index()].region());
+
+            if (maxLevel_[region] > maxLevel)
+            {
+                maxSurface = surfI;
+                maxLevel = maxLevel_[region];
+                maxHit = hit;
+            }
+        }
+    }
+
+    if (maxSurface == -1)
+    {
+        // maxLevel unchanged. No interesting surface hit.
+        maxHit.setMiss();
+    }
+
+    return maxSurface;
+}
+
+
+Foam::label Foam::refinementSurfaces::insideZone
+(
+    const labelList& surfaces,
+    const point& pt
+) const
+{
+    forAll(surfaces, i)
+    {
+        label surfI = surfaces[i];
+
+        if (closed_[surfI])
+        {
+            const triSurfaceMesh& s = operator[](surfI);
+
+            triSurfaceMesh::volumeType t = s.getVolumeType(pt);
+
+            if
+            (
+                (t == triSurfaceMesh::INSIDE && zoneInside_[surfI])
+             || (t == triSurfaceMesh::OUTSIDE && !zoneInside_[surfI])
+            )
+            {
+                return surfI;
+            }
+        }
+    }
+    return -1;
+}
+
+
+Foam::label Foam::refinementSurfaces::markInsidePoints
+(
+    const pointField& points,
+    PackedList<1>& isInside
+) const
+{
+    isInside.setSize(points.size());
+    isInside = 0u;
+
+    label nPointInside = 0;
+
+    forAll(points, pointI)
+    {
+        forAll(*this, surfI)
+        {
+            if (closed()[surfI])
+            {
+                const triSurfaceMesh& s = operator[](surfI);
+
+                triSurfaceMesh::volumeType t = s.getVolumeType(points[pointI]);
+
+                if (t == triSurfaceMesh::INSIDE)
+                {
+                    isInside.set(pointI, 1u);
+                    nPointInside++;
+                    break;
+                }
+            }
+        }
+    }
+
+    return nPointInside;
+}
+
+
+void Foam::refinementSurfaces::setMinLevelFields
+(
+    const PtrList<searchableSurface>& shells,
+    const labelList& shellLevels,
+    const boolList& shellRefineInside
+)
+{
+    typedef Foam::DimensionedField<label, triSurfaceGeoMesh>
+        triSurfaceLabelField;
+
+    minLevelFields_.setSize(size());
+
+    forAll(*this, surfI)
+    {
+        const triSurfaceMesh& surfMesh = operator[](surfI);
+
+        minLevelFields_.set
+        (
+            surfI,
+            new triSurfaceLabelField
+            (
+                IOobject
+                (
+                    surfMesh.IOobject::name(),
+                    surfMesh.time().constant(), // directory
+                    "triSurface",               // instance
+                    surfMesh,
+                    IOobject::NO_READ,
+                    IOobject::AUTO_WRITE,
+                    false
+                ),
+                surfMesh,
+                dimless
+            )
+        );
+    }
+
+    // Initialise fields to region wise minLevel
+    forAll(*this, surfI)
+    {
+        const triSurface& s = operator[](surfI);
+
+        triSurfaceLabelField& minLevelField = minLevelFields_[surfI];
+
+        forAll(s, i)
+        {
+            minLevelField[i] = minLevel_[globalRegion(surfI, s[i].region())];
+        }
+    }
+
+    // Adapt for triangles inside shells
+    forAll(*this, surfI)
+    {
+        const triSurface& s = operator[](surfI);
+        triSurfaceLabelField& minLevelField = minLevelFields_[surfI];
+
+        forAll(s, i)
+        {
+            point fc = s[i].centre(s.points());
+
+            forAll(shells, shellI)
+            {
+                // Which side of shell is to be refined
+                searchableSurface::volumeType refSide =
+                (
+                    shellRefineInside[shellI]
+                  ? searchableSurface::INSIDE
+                  : searchableSurface::OUTSIDE
+                );
+
+                // Find whether point is inside or outside shell
+                searchableSurface::volumeType t =
+                    shells[shellI].getVolumeType(fc);
+
+                if (t == refSide)
+                {
+                    minLevelField[i] = max
+                    (
+                        minLevelField[i],
+                        shellLevels[shellI]
+                    );
+                }
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
new file mode 100644
index 0000000000..9a366d4401
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
@@ -0,0 +1,279 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    refinementSurfaces
+
+Description
+    Container for triSurfaces used for surface-driven refinement.
+    These contain all the data about the level of refinement needed per
+    surface.
+
+SourceFiles
+    refinementSurfaces.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementSurfaces_H
+#define refinementSurfaces_H
+
+#include "triSurfaceMeshes.H"
+#include "PackedList.H"
+#include "triSurfaceGeoMesh.H"
+#include "triSurfaceFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class searchableSurface;
+
+/*---------------------------------------------------------------------------*\
+                           Class refinementSurfaces Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementSurfaces
+:
+    public triSurfaceMeshes
+{
+    // Private data
+
+        //- Name (word)
+        wordList names_;
+
+        //- Per surface whether is closed
+        boolList closed_;
+
+        //- Per 'interface' surface : name of faceZone to put faces into
+        wordList faceZoneNames_;
+
+        //- Per 'interface' surface : name of cellZone to put cells into
+        wordList cellZoneNames_;
+
+        //- Per 'interface' surface : (only used if surface is closed)
+        //  whether to zone cells inside or outside surface.
+        boolList zoneInside_;
+
+
+        //- From local region number to global region number
+        labelList regionOffset_;
+
+        //- From global region number to refinement level
+        labelList minLevel_;
+
+        //- From global region number to refinement level
+        labelList maxLevel_;
+
+        //- Per surface refinement level adapted for shells.
+        PtrList<triSurfaceLabelField> minLevelFields_;
+
+
+    // Private Member Functions
+
+        static fileNameList extractFileNames(const PtrList<dictionary>&);
+
+        //- Disallow default bitwise copy construct
+        refinementSurfaces(const refinementSurfaces&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const refinementSurfaces&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from directory (io.instance()) and dictionaries
+        refinementSurfaces
+        (
+            const IOobject& io,
+            const PtrList<dictionary>&
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //- Names of surfaces
+            const wordList& names() const
+            {
+                return names_;
+            }
+
+            //- Per surface whether is closed
+            const boolList& closed() const
+            {
+                return closed_;
+            }
+
+            //- Per 'interface' surface : name of faceZone to put faces into
+            const wordList& faceZoneNames() const
+            {
+                return faceZoneNames_;
+            }
+
+            //- Per 'interface' surface : name of cellZone to put cells into
+            const wordList& cellZoneNames() const
+            {
+                return cellZoneNames_;
+            }
+
+            //- Per 'interface' surface : if closed: zonify cells inside surface
+            const boolList& zoneInside() const
+            {
+                return zoneInside_;
+            }
+
+            //- Get indices of named surfaces (surfaces with cellZoneName)
+            labelList getNamedSurfaces() const;
+
+
+            //- From local region number to global region number
+            const labelList& regionOffset() const
+            {
+                return regionOffset_;
+            }
+
+            //- From global region number to refinement level
+            const labelList& minLevel() const
+            {
+                return minLevel_;
+            }
+
+            //- From global region number to refinement level
+            const labelList& maxLevel() const
+            {
+                return maxLevel_;
+            }
+
+
+        // Helper
+
+            //- From surface and region on surface to global region
+            label globalRegion(const label surfI, const label regionI) const
+            {
+                return regionOffset_[surfI]+regionI;
+            }
+
+            //- From triangle on surface to global region
+            label triangleRegion(const label surfI, const label triI) const
+            {
+                const triSurface& s = operator[](surfI);
+
+                return globalRegion(surfI, s[triI].region());
+            }
+
+            //- Min level for surface and region on surface
+            label minLevel(const label surfI, const label regionI) const
+            {
+                return minLevel_[globalRegion(surfI, regionI)];
+            }
+
+            //- Max level for surface and region on surface
+            label maxLevel(const label surfI, const label regionI) const
+            {
+                return maxLevel_[globalRegion(surfI, regionI)];
+            }
+
+            label nRegions() const
+            {
+                return minLevel_.size();
+            }
+
+            //- Minlevel updated for refinement shells
+            const triSurfaceLabelField& minLevelField(const label surfI) const
+            {
+                return minLevelFields_[surfI];
+            }
+
+            //- Calculate minLevelFields
+            void setMinLevelFields
+            (
+                const PtrList<searchableSurface>& shells,
+                const labelList& shellLevels,
+                const boolList& shellRefineInside
+            );
+
+            //- Helper: is surface closed?
+            static bool isSurfaceClosed(const triSurface&);
+
+            //- Helper: orient (closed only) surfaces so keepPoint is outside.
+            static void orientSurface
+            (
+                const point& keepPoint,
+                triSurfaceMesh& surface
+            );
+
+            //- Helper: count number of triangles per region
+            static labelList countRegions(const triSurface&);
+
+
+        // Searching
+
+            //- Find intersection of edge. Return -1 or first surface
+            //  with higher (than currentLevel) minlevel.
+            //  Return surface number and hit info.
+            label findHigherIntersection
+            (
+                const point& start,
+                const point& end,
+                const label currentLevel,   // current cell refinement level
+                pointIndexHit&
+            ) const;
+
+            //- Find intersection with max level. Return -1 or the surface
+            //  with the highest maxLevel above currentLevel
+            label findHighestIntersection
+            (
+                const point& start,
+                const point& end,
+                const label currentLevel,   // current cell refinement level
+                pointIndexHit&
+            ) const;
+
+            //- Detect if a point is 'inside' (depending on zoneInside flag) a
+            //  zoneable surface. Returns -1 if not, returns first surface it
+            //  is.
+            label insideZone(const labelList& surfaces, const point& pt) const;
+
+
+            //- Mark for all points whether it is inside any closed surface
+            //  Return number of inside points.
+            label markInsidePoints(const pointField&, PackedList<1>& isInside)
+             const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
new file mode 100644
index 0000000000..ced0f29594
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
@@ -0,0 +1,263 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "ExactParticle.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class ParticleType>
+template<class TrackingData>
+Foam::label Foam::ExactParticle<ParticleType>::track
+(
+    const vector& endPosition,
+    TrackingData& td
+)
+{
+    this->facei_ = -1;
+
+    // Tracks to endPosition or stop on boundary
+    while(!this->onBoundary() && this->stepFraction_ < 1.0 - SMALL)
+    {
+        this->stepFraction_ +=
+            trackToFace(endPosition, td)
+           *(1.0 - this->stepFraction_);
+    }
+
+    return this->facei_;
+}
+
+
+template<class ParticleType>
+Foam::label Foam::ExactParticle<ParticleType>::track
+(
+    const vector& endPosition
+)
+{
+    int dummyTd;
+    return track(endPosition, dummyTd);
+}
+
+
+template<class ParticleType>
+template<class TrackingData>
+Foam::scalar Foam::ExactParticle<ParticleType>::trackToFace
+(
+    const vector& endPosition,
+    TrackingData& td
+)
+{
+    const polyMesh& mesh = this->cloud().pMesh();
+    const labelList& cFaces = mesh.cells()[this->celli_];
+
+    point intersection(vector::zero);
+    scalar trackFraction = VGREAT;
+    label hitFacei = -1;
+
+    const vector vec = endPosition-this->position_;
+
+    forAll(cFaces, i)
+    {
+        label facei = cFaces[i];
+
+        if (facei != this->face())
+        {
+            pointHit inter = mesh.faces()[facei].intersection
+            (
+                this->position_,
+                vec,
+                mesh.faceCentres()[facei],
+                mesh.points(),
+                intersection::HALF_RAY
+            );
+
+            if (inter.hit() && inter.distance() < trackFraction)
+            {
+                trackFraction = inter.distance();
+                hitFacei = facei;
+                intersection = inter.hitPoint();
+            }
+        }
+    }
+
+
+    if (hitFacei != -1)
+    {
+        if (trackFraction > 1.0)
+        {
+            // Nearest intersection beyond endPosition so we hit endPosition.
+            this->position_ = endPosition;
+            this->facei_ = -1;
+            return 1.0;
+        }
+        else
+        {
+            this->position_ = intersection;
+            this->facei_ = hitFacei;
+        }
+    }
+    else
+    {
+        // Did not find any intersection. Fall back to original approximate
+        // algorithm
+        return Particle<ParticleType>::trackToFace
+        (
+            endPosition,
+            td
+        );
+    }
+
+
+    // Normal situation (trackFraction 0..1)
+
+    bool internalFace = this->cloud().internalFace(this->facei_);
+
+    // change cell
+    if (internalFace) // Internal face
+    {
+        if (this->celli_ == mesh.faceOwner()[this->facei_])
+        {
+            this->celli_ = mesh.faceNeighbour()[this->facei_];
+        }
+        else if (this->celli_ == mesh.faceNeighbour()[this->facei_])
+        {
+            this->celli_ = mesh.faceOwner()[this->facei_];
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "ExactParticle::trackToFace"
+                "(const vector&, TrackingData&)"
+            )<< "addressing failure" << nl
+             << abort(FatalError);
+        }
+    }
+    else
+    {
+        ParticleType& p = static_cast<ParticleType&>(*this);
+
+        // Soft-sphere algorithm ignores the boundary
+        if (p.softImpact())
+        {
+            trackFraction = 1.0;
+            this->position_ = endPosition;
+        }
+
+        label patchi = patch(this->facei_);
+        const polyPatch& patch = mesh.boundaryMesh()[patchi];
+
+        if (isA<wedgePolyPatch>(patch))
+        {
+            p.hitWedgePatch
+            (
+                static_cast<const wedgePolyPatch&>(patch), td
+            );
+        }
+        else if (isA<symmetryPolyPatch>(patch))
+        {
+            p.hitSymmetryPatch
+            (
+                static_cast<const symmetryPolyPatch&>(patch), td
+            );
+        }
+        else if (isA<cyclicPolyPatch>(patch))
+        {
+            p.hitCyclicPatch
+            (
+                static_cast<const cyclicPolyPatch&>(patch), td
+            );
+        }
+        else if (isA<processorPolyPatch>(patch))
+        {
+            p.hitProcessorPatch
+            (
+                static_cast<const processorPolyPatch&>(patch), td
+            );
+        }
+        else if (isA<wallPolyPatch>(patch))
+        {
+            p.hitWallPatch
+            (
+                static_cast<const wallPolyPatch&>(patch), td
+            );
+        }
+        else if (isA<polyPatch>(patch))
+        {
+            p.hitPatch
+            (
+                static_cast<const polyPatch&>(patch), td
+            );
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "ExactParticle::trackToFace"
+                "(const vector& endPosition, scalar& trackFraction)"
+            )<< "patch type " << patch.type() << " not suported" << nl
+             << abort(FatalError);
+        }
+    }
+
+    // If the trackFraction = 0 something went wrong.
+    // Either the particle is flipping back and forth across a face perhaps
+    // due to velocity interpolation errors or it is in a "hole" in the mesh
+    // caused by face warpage.
+    // In both cases resolve the positional ambiguity by moving the particle
+    // slightly towards the cell-centre.
+    if (trackFraction < SMALL)
+    {
+        this->position_ +=
+            1.0e-6*(mesh.cellCentres()[this->celli_] - this->position_);
+    }
+
+    return trackFraction;
+}
+
+
+template<class ParticleType>
+Foam::scalar Foam::ExactParticle<ParticleType>::trackToFace
+(
+    const vector& endPosition
+)
+{
+    int dummyTd;
+    return trackToFace(endPosition, dummyTd);
+}
+
+
+template<class ParticleType>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const ExactParticle<ParticleType>& p
+)
+{
+    return operator<<(os, static_cast<Particle<ParticleType> >(p));
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.H b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.H
new file mode 100644
index 0000000000..df4d0c61c3
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.H
@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    ExactParticle
+
+Description
+    Special version of Particle to do tracking on non-convex cells.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ExactParticle_H
+#define ExactParticle_H
+
+#include "face.H"
+#include "Particle.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class ExactParticle>
+class Cloud;
+
+// Forward declaration of friend functions and operators
+
+template<class ParticleType>
+class ExactParticle;
+
+template<class ParticleType>
+Ostream& operator<<
+(
+    Ostream&,
+    const ExactParticle<ParticleType>&
+);
+
+
+/*---------------------------------------------------------------------------*\
+                           Class ExactParticle Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class ParticleType>
+class ExactParticle
+:
+    public Particle<ParticleType>
+{
+
+public:
+
+    friend class Cloud<ParticleType>;
+
+
+    // Constructors
+
+        //- Construct from components
+        ExactParticle
+        (
+            const Cloud<ParticleType>& cloud,
+            const vector& position,
+            const label celli
+        )
+        :
+            Particle<ParticleType>(cloud, position, celli)
+        {}
+            
+
+        //- Construct from Istream
+        ExactParticle
+        (
+            const Cloud<ParticleType>& cloud,
+            Istream& is,
+            bool readFields = true
+        )
+        :
+            Particle<ParticleType>(cloud, is, readFields)
+        {}
+
+
+        //- Factory class to read-construct particles used for parallel transfer
+        class iNew
+        {
+
+            // Private data
+
+            const Cloud<ParticleType>& cloud_;
+
+
+        public:
+
+            iNew(const Cloud<ParticleType>& cloud)
+            :
+                cloud_(cloud)
+            {}
+
+            autoPtr<ParticleType> operator()(Istream& is) const
+            {
+                return autoPtr<ParticleType>
+                (
+                    new ParticleType(cloud_, is)
+                );
+            }
+        };
+
+
+    // Destructor
+
+        virtual ~ExactParticle()
+        {}
+
+
+    // Member Functions
+
+            //- Track particle to end of trajectory
+            //  or until it hits the boundary.
+            //  On entry 'stepFraction()' should be set to the fraction of the
+            //  time-step at which the tracking starts and on exit it contains
+            //  the fraction of the time-step completed.
+            //  Returns the boundary face index if the track stops at the
+            //  boundary, -1 otherwise.
+            template<class TrackingData>
+            label track
+            (
+                const vector& endPosition,
+                TrackingData& td
+            );
+
+            //- Calls the templated track with dummy TrackingData
+            label track(const vector& endPosition);
+
+            //- Track particle to a given position and returns 1.0 if the
+            //  trajectory is completed without hitting a face otherwise
+            //  stops at the face and returns the fraction of the trajectory
+            //  completed.
+            //  on entry 'stepFraction()' should be set to the fraction of the
+            //  time-step at which the tracking starts.
+            template<class TrackingData>
+            scalar trackToFace
+            (
+                const vector& endPosition,
+                TrackingData& td
+            );
+
+            //- Calls the templated trackToFace with dummy TrackingData
+            scalar trackToFace(const vector& endPosition);
+
+
+    // Ostream Operator
+
+        friend Ostream& operator<< <ParticleType>
+        (
+            Ostream&,
+            const ExactParticle<ParticleType>&
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "ExactParticle.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/Particle.H b/src/autoMesh/autoHexMesh/trackedParticle/Particle.H
new file mode 100644
index 0000000000..56f97b9ad9
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/Particle.H
@@ -0,0 +1,431 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    Particle
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Particle_H
+#define Particle_H
+
+#include "vector.H"
+#include "IDLList.H"
+#include "labelList.H"
+#include "pointField.H"
+#include "typeInfo.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+template<class Particle>
+class Cloud;
+
+class wedgePolyPatch;
+class symmetryPolyPatch;
+class cyclicPolyPatch;
+class processorPolyPatch;
+class wallPolyPatch;
+class polyPatch;
+
+// Forward declaration of friend functions and operators
+
+template<class ParticleType>
+class Particle;
+
+template<class ParticleType>
+Ostream& operator<<
+(
+    Ostream&,
+    const Particle<ParticleType>&
+);
+
+
+/*---------------------------------------------------------------------------*\
+                           Class Particle Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class ParticleType>
+class Particle
+:
+    public IDLList<ParticleType>::link
+{
+
+protected:
+
+        //- Reference to the particle cloud
+        const Cloud<ParticleType>& cloud_;
+
+        //- Position of particle
+        vector position_;
+
+        //- Index of the cell it is in
+        label celli_;
+
+        //- Face index if the particle is on a face otherwise -1
+        label facei_;
+
+        //- Fraction of time-step completed
+        scalar stepFraction_;
+
+
+    // Private member functions
+
+        //- Return the 'lambda' value for the position, p, on the face,
+        // where, p = from + lamda*(to - from)
+        // for non-static meshes
+        inline scalar lambda
+        (
+            const vector& from,
+            const vector& to,
+            const label facei,
+            const scalar stepFraction
+        );
+
+        //- Return the 'lambda' value for the position, p, on the face,
+        // where, p = from + lamda*(to - from)
+        // for static meshes
+        inline scalar lambda
+        (
+            const vector& from,
+            const vector& to,
+            const label facei
+        );
+
+        //- Return the faces between position and cell centre
+        labelList findFaces
+        (
+            const vector& position
+        );
+
+        //- Return the faces between position and cell centre
+        labelList findFaces
+        (
+            const vector& position,
+            const label celli,
+            const scalar stepFraction
+        );
+
+
+        //- Overridable function to handle the particle hitting a wedgePatch
+        template<class TrackingData>
+        void hitWedgePatch
+        (
+            const wedgePolyPatch&,
+            TrackingData& td
+        );
+
+        //- Overridable function to handle the particle hitting a symmetryPatch
+        template<class TrackingData>
+        void hitSymmetryPatch
+        (
+            const symmetryPolyPatch&,
+            TrackingData& td
+        );
+
+        //- Overridable function to handle the particle hitting a cyclicPatch
+        template<class TrackingData>
+        void hitCyclicPatch
+        (
+            const cyclicPolyPatch&,
+            TrackingData& td
+        );
+
+        //- Overridable function to handle the particle hitting a processorPatch
+        template<class TrackingData>
+        void hitProcessorPatch
+        (
+            const processorPolyPatch&,
+            TrackingData& td
+        );
+
+        //- Overridable function to handle the particle hitting a wallPatch
+        template<class TrackingData>
+        void hitWallPatch
+        (
+            const wallPolyPatch&,
+            TrackingData& td
+        );
+
+        //- Overridable function to handle the particle hitting a general patch
+        template<class TrackingData>
+        void hitPatch
+        (
+            const polyPatch&,
+            TrackingData& td
+        );
+
+        //- Transform the position the particle
+        //  according to the given transformation tensor
+        void transformPosition(const tensor& T);
+
+        //- Transform the physical properties of the particle
+        //  according to the given transformation tensor
+        void transformProperties(const tensor& T);
+
+        //- Transform the physical properties of the particle
+        //  according to the given separation vector
+        void transformProperties(const vector& separation);
+
+        //- Convert global addressing to the processor patch
+        //  local equivalents
+        template<class TrackingData>
+        void prepareForParallelTransfer(const label patchi, TrackingData& td);
+
+        //- Convert processor patch addressing to the global equivalents
+        //  and set the celli to the face-neighbour
+        template<class TrackingData>
+        void correctAfterParallelTransfer(const label patchi, TrackingData& td);
+
+
+public:
+
+    friend class Cloud<ParticleType>;
+
+
+    //- Runtime type information
+    TypeName("Particle");
+
+
+    //- Class used to pass tracking data to the trackToFace function
+    class trackData
+    {
+
+        // Private data
+
+            //- Reference to the cloud containing this particle
+            Cloud<ParticleType>& cloud_;
+
+
+    public:
+
+        bool switchProcessor;
+        bool keepParticle;
+
+
+        // Constructors
+
+            inline trackData
+            (
+                Cloud<ParticleType>& cloud
+            );
+
+
+        // Member functions
+
+            inline Cloud<ParticleType>& cloud();
+    };
+
+
+    // Constructors
+
+        //- Construct from components
+        Particle
+        (
+            const Cloud<ParticleType>&,
+            const vector& position,
+            const label celli
+        );
+
+        //- Construct from Istream
+        Particle
+        (
+            const Cloud<ParticleType>&,
+            Istream&,
+            bool readFields = true
+        );
+
+        //- Factory class to read-construct particles used for parallel transfer
+        class iNew
+        {
+
+            // Private data
+
+            const Cloud<ParticleType>& cloud_;
+
+
+        public:
+
+            iNew(const Cloud<ParticleType>& cloud)
+            :
+                cloud_(cloud)
+            {}
+
+            autoPtr<ParticleType> operator()(Istream& is) const
+            {
+                return autoPtr<ParticleType>(new ParticleType(cloud_, is));
+            }
+        };
+
+
+    // Destructor
+
+        virtual ~Particle()
+        {}
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return true if particle is in cell
+            inline bool inCell();
+
+            //- Return true if position is in cell i
+            inline bool inCell
+            (
+                const vector& position,
+                const label celli,
+                const scalar stepFraction
+            );
+
+            //- Return current particle position
+            inline const vector& position() const;
+
+            //- Return current particle position
+            inline vector& position();
+
+            //- Return current cell particle is in
+            inline label cell() const;
+
+            //- Return current face particle is on otherwise -1
+            inline label face() const;
+
+            //- Return reference to the particle cloud
+            inline const Cloud<ParticleType>& cloud() const;
+
+            //- Return the impact model to be used, soft or hard (default).
+            inline bool softImpact() const;
+
+
+        // Check
+
+            //- Is the particle on the boundary/(or outside the domain)?
+            inline bool onBoundary() const;
+
+            //- Which patch is particle on
+            inline label patch(const label facei) const;
+
+            //- Which face of this patch is this particle on
+            inline label patchFace(const label patchi, const label facei) const;
+
+            //- The nearest distance to a wall that
+            //  the particle can be in the n direction
+            inline scalar wallImpactDistance(const vector& n) const;
+
+            //- Return the fraction of time-step completed
+            inline scalar& stepFraction();
+
+            //-  Return the fraction of time-step completed
+            inline scalar stepFraction() const;
+
+
+        // Track
+
+            //- Track particle to end of trajectory
+            //  or until it hits the boundary.
+            //  On entry 'stepFraction()' should be set to the fraction of the
+            //  time-step at which the tracking starts and on exit it contains
+            //  the fraction of the time-step completed.
+            //  Returns the boundary face index if the track stops at the
+            //  boundary, -1 otherwise.
+            template<class TrackingData>
+            label track
+            (
+                const vector& endPosition,
+                TrackingData& td
+            );
+
+            //- Calls the templated track with dummy TrackingData
+            label track(const vector& endPosition);
+
+            //- Track particle to a given position and returns 1.0 if the
+            //  trajectory is completed without hitting a face otherwise
+            //  stops at the face and returns the fraction of the trajectory
+            //  completed.
+            //  on entry 'stepFraction()' should be set to the fraction of the
+            //  time-step at which the tracking starts.
+            template<class TrackingData>
+            scalar trackToFace
+            (
+                const vector& endPosition,
+                TrackingData& td
+            );
+
+            //- Calls the templated trackToFace with dummy TrackingData
+            scalar trackToFace(const vector& endPosition);
+
+            //- Return the index of the face to be used in the interpolation routine
+            inline label faceInterpolation() const;
+
+
+    // I-O
+
+        //- Write the fields associated with the owner cloud
+        static void writeFields
+        (
+            const Cloud<ParticleType>& c
+        );
+
+
+    // Ostream Operator
+
+        friend Ostream& operator<< <ParticleType>
+        (
+            Ostream&,
+            const Particle<ParticleType>&
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "ParticleI.H"
+
+#define defineParticleTypeNameAndDebug(Type, DebugSwitch)                     \
+    template<>                                                                \
+    const Foam::word Particle<Type>::typeName(#Type);                         \
+    template<>                                                                \
+    int Particle<Type>::debug(Foam::debug::debugSwitch(#Type, DebugSwitch));
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "Particle.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.C b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.C
new file mode 100644
index 0000000000..94a67e9595
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.C
@@ -0,0 +1,261 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*----------------------------------------------------------------------------*/
+
+#include "trackedParticle.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+//- Construct from components
+Foam::trackedParticle::trackedParticle
+(
+    const Cloud<trackedParticle>& c,
+    const vector& position,
+    const label celli,
+    const point& end,
+    const label level,
+    const label i,
+    const label j
+)
+:
+    ExactParticle<trackedParticle>(c, position, celli),
+    end_(end),
+    level_(level),
+    i_(i),
+    j_(j)
+{}
+
+
+//- Construct from Istream
+Foam::trackedParticle::trackedParticle
+(
+    const Cloud<trackedParticle>& c,
+    Istream& is,
+    bool readFields
+)
+:
+    ExactParticle<trackedParticle>(c, is)
+{
+    if (readFields)
+    {
+        if (is.format() == IOstream::ASCII)
+        {
+            is >> end_;
+            level_ = readLabel(is);
+            i_ = readLabel(is);
+            j_ = readLabel(is);
+        }
+        else
+        {
+            is.read
+            (
+                reinterpret_cast<char*>(&end_),
+                sizeof(end_) + sizeof(level_) + sizeof(i_) + sizeof(j_)
+            );
+        }
+    }
+
+    // Check state of Istream
+    is.check
+    (
+        "trackedParticle::trackedParticle"
+        "(const Cloud<trackedParticle>&, Istream&, bool)"
+    );
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::trackedParticle::move(trackedParticle::trackData& td)
+{
+    td.switchProcessor = false;
+    td.keepParticle = true;
+
+    scalar deltaT = cloud().pMesh().time().deltaT().value();
+    scalar tEnd = (1.0 - stepFraction())*deltaT;
+    scalar dtMax = tEnd;
+
+    while (td.keepParticle && !td.switchProcessor && tEnd > SMALL)
+    {
+        // set the lagrangian time-step
+        scalar dt = min(dtMax, tEnd);
+
+        // mark visited cell with max level.
+        td.maxLevel()[cell()] = max(td.maxLevel()[cell()], level_);
+
+        dt *= trackToFace(end_, td);
+
+        tEnd -= dt;
+        stepFraction() = 1.0 - tEnd/deltaT;
+    }
+
+    return td.keepParticle;
+}
+
+
+void Foam::trackedParticle::hitWedgePatch
+(
+    const wedgePolyPatch&,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::trackedParticle::hitWedgePatch
+(
+    const wedgePolyPatch&,
+    int&
+)
+{}
+
+
+void Foam::trackedParticle::hitSymmetryPatch
+(
+    const symmetryPolyPatch&,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::trackedParticle::hitSymmetryPatch
+(
+    const symmetryPolyPatch&,
+    int&
+)
+{}
+
+
+void Foam::trackedParticle::hitCyclicPatch
+(
+    const cyclicPolyPatch&,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::trackedParticle::hitCyclicPatch
+(
+    const cyclicPolyPatch&,
+    int&
+)
+{}
+
+
+void Foam::trackedParticle::hitProcessorPatch
+(
+    const processorPolyPatch&,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.switchProcessor = true;
+}
+
+
+void Foam::trackedParticle::hitProcessorPatch
+(
+    const processorPolyPatch&,
+    int&
+)
+{}
+
+
+void Foam::trackedParticle::hitWallPatch
+(
+    const wallPolyPatch& wpp,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::trackedParticle::hitWallPatch
+(
+    const wallPolyPatch& wpp,
+    int&
+)
+{}
+
+
+void Foam::trackedParticle::hitPatch
+(
+    const polyPatch& wpp,
+    trackedParticle::trackData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::trackedParticle::hitPatch
+(
+    const polyPatch& wpp,
+    int&
+)
+{}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const trackedParticle& p)
+{
+    if (os.format() == IOstream::ASCII)
+    {
+        os  << static_cast<const ExactParticle<trackedParticle>&>(p)
+            << token::SPACE << p.end_
+            << token::SPACE << p.level_
+            << token::SPACE << p.i_
+            << token::SPACE << p.j_;
+    }
+    else
+    {
+        os  << static_cast<const ExactParticle<trackedParticle>&>(p);
+        os.write
+        (
+            reinterpret_cast<const char*>(&p.end_),
+            sizeof(p.end_) + sizeof(p.level_) + sizeof(p.i_) + sizeof(p.j_)
+        );
+    }
+
+    // Check state of Ostream
+    os.check("Ostream& operator<<(Ostream&, const trackedParticle&)");
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.H b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.H
new file mode 100644
index 0000000000..e064a4da81
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticle.H
@@ -0,0 +1,276 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 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
+    trackedParticle
+
+Description
+    Particle class that marks cells it passes through. Used to mark cells
+    visited by feature edges. Uses ExactParticle tracking class so
+    will work on concave cells.
+
+SourceFiles
+    trackedParticle.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef trackedParticle_H
+#define trackedParticle_H
+
+#include "ExactParticle.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class trackedParticleCloud;
+
+/*---------------------------------------------------------------------------*\
+                           Class trackedParticle Declaration
+\*---------------------------------------------------------------------------*/
+
+class trackedParticle
+:
+    public ExactParticle<trackedParticle>
+{
+    // Private data
+
+        //- end point to track to
+        point end_;
+
+        //- level of this particle
+        label level_;
+
+        //- passive label
+        label i_;
+
+        //- passive label
+        label j_;
+
+public:
+
+    friend class Cloud<trackedParticle>;
+
+    //- Class used to pass tracking data to the trackToFace function
+    class trackData
+    {
+        //- Reference to the cloud containing this particle
+        Cloud<trackedParticle>& cloud_;
+
+        labelList& maxLevel_;
+
+    public:
+
+        bool switchProcessor;
+        bool keepParticle;
+
+
+        // Constructors
+
+            trackData(Cloud<trackedParticle>& cloud, labelList& maxLevel)
+            :
+                cloud_(cloud),
+                maxLevel_(maxLevel)
+            {}
+
+
+        // Member functions
+
+            Cloud<trackedParticle>& cloud()
+            {
+                return cloud_;
+            }
+
+            labelList& maxLevel()
+            {
+                return maxLevel_;
+            }
+    };
+
+
+
+    // Constructors
+
+        //- Construct from components
+        trackedParticle
+        (
+            const Cloud<trackedParticle>& c,
+            const vector& position,
+            const label celli,
+            const point& end,
+            const label level,
+            const label i,
+            const label j
+        );
+
+        //- Construct from Istream
+        trackedParticle
+        (
+            const Cloud<trackedParticle>& c,
+            Istream& is,
+            bool readFields = true
+        );
+
+        //- Construct and return a clone
+        autoPtr<trackedParticle> clone() const
+        {
+            return autoPtr<trackedParticle>(new trackedParticle(*this));
+        }
+
+
+    // Member Functions
+
+        //- point to track to
+        point& end()
+        {
+            return end_;
+        }
+
+        //- transported label
+        label& i()
+        {
+            return i_;
+        }
+
+        //- transported label
+        label& j()
+        {
+            return j_;
+        }
+
+
+
+        // Tracking
+
+            //- Track all particles to their end point
+            bool move(trackData&);
+
+
+            //- Overridable function to handle the particle hitting a wedge
+            void hitWedgePatch
+            (
+                const wedgePolyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitWedgePatch
+            (
+                const wedgePolyPatch&,
+                int&
+            );
+
+            //- Overridable function to handle the particle hitting a
+            //  symmetryPlane
+            void hitSymmetryPatch
+            (
+                const symmetryPolyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitSymmetryPatch
+            (
+                const symmetryPolyPatch&,
+                int&
+            );
+
+            //- Overridable function to handle the particle hitting a cyclic
+            void hitCyclicPatch
+            (
+                const cyclicPolyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitCyclicPatch
+            (
+                const cyclicPolyPatch&,
+                int&
+            );
+
+            //- Overridable function to handle the particle hitting a
+            //- processorPatch
+            void hitProcessorPatch
+            (
+                const processorPolyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitProcessorPatch
+            (
+                const processorPolyPatch&,
+                int&
+            );
+
+            //- Overridable function to handle the particle hitting a wallPatch
+            void hitWallPatch
+            (
+                const wallPolyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitWallPatch
+            (
+                const wallPolyPatch&,
+                int&
+            );
+
+            //- Overridable function to handle the particle hitting a polyPatch
+            void hitPatch
+            (
+                const polyPatch&,
+                trackedParticle::trackData& td
+            );
+            void hitPatch
+            (
+                const polyPatch&,
+                int&
+            );
+
+
+    // Ostream Operator
+
+        friend Ostream& operator<<(Ostream&, const trackedParticle&);
+
+
+};
+
+
+template<>
+inline bool contiguous<trackedParticle>()
+{
+    return true;
+}
+
+//template<>
+//void Cloud<trackedParticle>::readFields();
+//
+//template<>
+//void Cloud<trackedParticle>::writeFields() const;
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/trackedParticleCloud.C b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticleCloud.C
new file mode 100644
index 0000000000..704d227e58
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/trackedParticle/trackedParticleCloud.C
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "trackedParticle.H"
+#include "Cloud.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineParticleTypeNameAndDebug(trackedParticle, 0);
+defineTemplateTypeNameAndDebug(Cloud<trackedParticle>, 0);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //