From be461afe5a9e960163f0d23e74af9be3c713890f Mon Sep 17 00:00:00 2001
From: Chris Greenshields <chris@dash.opencfd.co.uk>
Date: Fri, 4 Jul 2008 22:20:24 +0100
Subject: [PATCH 01/12] Change to Doxyfile so the collaboration diagrams are
 not huge

---
 doc/Doxygen/Doxyfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/Doxygen/Doxyfile b/doc/Doxygen/Doxyfile
index 13c36d9d30..a0d244d89a 100644
--- a/doc/Doxygen/Doxyfile
+++ b/doc/Doxygen/Doxyfile
@@ -1259,7 +1259,7 @@ DOT_GRAPH_MAX_NODES    = 50
 # code bases. Also note that the size of a graph can be further restricted by
 # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
 
-MAX_DOT_GRAPH_DEPTH    = 0
+MAX_DOT_GRAPH_DEPTH    = 3
 
 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
 # background. This is disabled by default, which results in a white background.

From b7bb04e81b3126bccce4db4b3e8e5cb3b67d1d2f Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Mon, 7 Jul 2008 18:40:05 +0100
Subject: [PATCH 02/12] trisurfaceMeshes superceded by searchableSurfaces

---
 ...aceSlipDisplacementPointPatchVectorField.C | 291 ++++++++++--------
 ...aceSlipDisplacementPointPatchVectorField.H |  12 +-
 2 files changed, 177 insertions(+), 126 deletions(-)

diff --git a/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.C b/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.C
index cfedeb6112..7b035e0e4a 100644
--- a/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.C
+++ b/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.C
@@ -62,7 +62,6 @@ surfaceSlipDisplacementPointPatchVectorField
 )
 :
     pointPatchVectorField(p, iF),
-    surfaceNames_(),
     projectMode_(NEAREST),
     projectDir_(vector::zero),
     wedgePlane_(-1)
@@ -78,7 +77,7 @@ surfaceSlipDisplacementPointPatchVectorField
 )
 :
     pointPatchVectorField(p, iF, dict),
-    surfaceNames_(dict.lookup("projectSurfaces")),
+    surfacesDict_(dict.subDict("geometry")),
     projectMode_(followModeNames_.read(dict.lookup("followMode"))),
     projectDir_(dict.lookup("projectDirection")),
     wedgePlane_(readLabel(dict.lookup("wedgePlane"))),
@@ -96,7 +95,7 @@ surfaceSlipDisplacementPointPatchVectorField
 )
 :
     pointPatchVectorField(p, iF),
-    surfaceNames_(ppf.surfaceNames()),
+    surfacesDict_(ppf.surfacesDict()),
     projectMode_(ppf.projectMode()),
     projectDir_(ppf.projectDir()),
     wedgePlane_(ppf.wedgePlane()),
@@ -111,7 +110,7 @@ surfaceSlipDisplacementPointPatchVectorField
 )
 :
     pointPatchVectorField(ppf),
-    surfaceNames_(ppf.surfaceNames()),
+    surfacesDict_(ppf.surfacesDict()),
     projectMode_(ppf.projectMode()),
     projectDir_(ppf.projectDir()),
     wedgePlane_(ppf.wedgePlane()),
@@ -127,7 +126,7 @@ surfaceSlipDisplacementPointPatchVectorField
 )
 :
     pointPatchVectorField(ppf, iF),
-    surfaceNames_(ppf.surfaceNames()),
+    surfacesDict_(ppf.surfacesDict()),
     projectMode_(ppf.projectMode()),
     projectDir_(ppf.projectDir()),
     wedgePlane_(ppf.wedgePlane()),
@@ -137,14 +136,14 @@ surfaceSlipDisplacementPointPatchVectorField
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const triSurfaceMeshes& surfaceSlipDisplacementPointPatchVectorField::
+const searchableSurfaces& surfaceSlipDisplacementPointPatchVectorField::
 surfaces() const
 {
     if (!surfacesPtr_.valid())
     {
         surfacesPtr_.reset
         (
-            new triSurfaceMeshes
+            new searchableSurfaces
             (
                 IOobject
                 (
@@ -155,7 +154,7 @@ surfaces() const
                     IOobject::MUST_READ,
                     IOobject::NO_WRITE
                 ),
-                surfaceNames_
+                surfacesDict_
             )
         );
     }
@@ -215,128 +214,180 @@ void surfaceSlipDisplacementPointPatchVectorField::evaluate
         );
     const pointField& points0 = motionSolver.points0();
 
-    forAll(localPoints, i)
+
+//XXXXXX
+
+
+    pointField start(meshPoints.size());
+    forAll(start, i)
     {
-        if (zonePtr && (zonePtr->whichPoint(meshPoints[i]) >= 0))
+        start[i] = points0[meshPoints[i]] + displacement[i];
+    }
+
+    if (projectMode_ == NEAREST)
+    {
+        List<pointIndexHit> nearest;
+        labelList hitSurfaces;
+        surfaces().findNearest
+        (
+            start,
+            scalarField(start.size(), sqr(projectLen)),
+            hitSurfaces,
+            nearest
+        );
+
+        forAll(nearest, i)
         {
-            // Fixed point. Reset to point0 location.
-
-            //Pout<< "    Fixed point:" << meshPoints[i]
-            //    << " coord:" << localPoints[i]
-            //    << " should be at:" << points0[meshPoints[i]]
-            //    << endl;
-            displacement[i] = points0[meshPoints[i]] - localPoints[i];
-        }
-        else
-        {
-            point start(points0[meshPoints[i]] + displacement[i]);
-
-            scalar offset = 0;
-            pointIndexHit intersection;
-
-            if (projectMode_ == NEAREST)
+            if (zonePtr && (zonePtr->whichPoint(meshPoints[i]) >= 0))
             {
-                surfaces().findNearest(start, sqr(projectLen), intersection);
+                // Fixed point. Reset to point0 location.
+                displacement[i] = points0[meshPoints[i]] - localPoints[i];
             }
-            else
+            else if (nearest[i].hit())
             {
-                // Check if already on surface
-                surfaces().findNearest(start, sqr(SMALL), intersection);
-
-                if (!intersection.hit())
-                {
-                    // No nearest found. Do intersection
-
-                    if (projectMode_ == POINTNORMAL)
-                    {
-                        projectVec = projectLen*patch().pointNormals()[i];
-                    }
-
-                    // Knock out any wedge component
-                    if (wedgePlane_ >= 0 && wedgePlane_ <= vector::nComponents)
-                    {
-                        offset = start[wedgePlane_];
-                        start[wedgePlane_] = 0;
-                        projectVec[wedgePlane_] = 0;
-                    }
-
-                    label rightSurf0, rightSurf1;
-                    pointIndexHit rightHit0, rightHit1;
-                    surfaces().findNearestIntersection
-                    (
-                        start,
-                        start+projectVec,
-                        rightSurf0,
-                        rightHit0,
-                        rightSurf1,
-                        rightHit1
-                    );
-
-                    // Do intersection
-                    label leftSurf0, leftSurf1;
-                    pointIndexHit leftHit0, leftHit1;
-                    surfaces().findNearestIntersection
-                    (
-                        start,
-                        start-projectVec,
-                        leftSurf0,
-                        leftHit0,
-                        leftSurf1,
-                        leftHit1
-                    );
-
-                    if (rightHit0.hit())
-                    {
-                        if (leftHit0.hit())
-                        {
-                            if
-                            (
-                                magSqr(rightHit0.hitPoint()-start)
-                              < magSqr(leftHit0.hitPoint()-start)
-                            )
-                            {
-                                intersection = rightHit0;
-                            }
-                            else
-                            {
-                                intersection = leftHit0;
-                            }
-                        }
-                        else
-                        {
-                            intersection = rightHit0;
-                        }
-                    }
-                    else
-                    {
-                        if (leftHit0.hit())
-                        {
-                            intersection = leftHit0;
-                        }
-                    }
-                }
-            }
-
-            // Update *this from intersection point
-
-            if (intersection.hit())
-            {
-                point interPt = intersection.hitPoint();
-
-                if (wedgePlane_ >= 0 && wedgePlane_ <= vector::nComponents)
-                {
-                    interPt[wedgePlane_] += offset;
-                }
-                displacement[i] = interPt-points0[meshPoints[i]];
+                displacement[i] =
+                    nearest[i].hitPoint()
+                  - points0[meshPoints[i]];
             }
             else
             {
                 Pout<< "    point:" << meshPoints[i]
                     << " coord:" << localPoints[i]
-                    << "  did not find any intersection between ray from "
-                    << start-projectVec << " to " << start+projectVec
+                    << "  did not find any surface within " << projectLen
                     << endl;
-            }  
+            }
+        }
+    }
+    else
+    {
+        // Do tests on all points. Combine later on.
+
+        // 1. Check if already on surface
+        List<pointIndexHit> nearest;
+        {
+            labelList nearestSurface;
+            surfaces().findNearest
+            (
+                start,
+                scalarField(start.size(), sqr(SMALL)),
+                nearestSurface,
+                nearest
+            );
+        }
+
+        // 2. intersection. (combined later on with information from nearest
+        // above)
+        vectorField projectVecs(start.size(), projectVec);
+
+        if (projectMode_ == POINTNORMAL)
+        {
+            projectVecs = projectLen*patch().pointNormals();
+        }
+
+        // Knock out any wedge component
+        scalarField offset(start.size(), 0.0);
+        if (wedgePlane_ >= 0 && wedgePlane_ <= vector::nComponents)
+        {
+            forAll(offset, i)
+            {
+                offset[i] = start[i][wedgePlane_];
+                start[i][wedgePlane_] = 0;
+                projectVecs[i][wedgePlane_] = 0;
+            }
+        }
+
+        List<pointIndexHit> rightHit;
+        {
+            labelList rightSurf;
+            surfaces().findAnyIntersection
+            (
+                start,
+                start+projectVecs,
+                rightSurf,
+                rightHit
+            );
+        }
+        
+        List<pointIndexHit> leftHit;
+        {
+            labelList leftSurf;
+            surfaces().findAnyIntersection
+            (
+                start,
+                start-projectVecs,
+                leftSurf,
+                leftHit
+            );
+        }
+
+        // 3. Choose either -fixed, nearest, right, left.
+        forAll(displacement, i)
+        {
+            if (zonePtr && (zonePtr->whichPoint(meshPoints[i]) >= 0))
+            {
+                // Fixed point. Reset to point0 location.
+                displacement[i] = points0[meshPoints[i]] - localPoints[i];
+            }
+            else if (nearest[i].hit())
+            {
+                // Found nearest.
+                displacement[i] =
+                    nearest[i].hitPoint()
+                  - points0[meshPoints[i]];
+            }
+            else
+            {
+                pointIndexHit interPt;
+
+                if (rightHit[i].hit())
+                {
+                    if (leftHit[i].hit())
+                    {
+                        if
+                        (
+                            magSqr(rightHit[i].hitPoint()-start[i])
+                          < magSqr(leftHit[i].hitPoint()-start[i])
+                        )
+                        {
+                            interPt = rightHit[i];
+                        }
+                        else
+                        {
+                            interPt = leftHit[i];
+                        }
+                    }
+                    else
+                    {
+                        interPt = rightHit[i];
+                    }
+                }
+                else
+                {
+                    if (leftHit[i].hit())
+                    {
+                        interPt = leftHit[i];
+                    }
+                }
+
+
+                if (interPt.hit())
+                {
+                    if (wedgePlane_ >= 0 && wedgePlane_ <= vector::nComponents)
+                    {
+                        interPt.rawPoint()[wedgePlane_] += offset[i];
+                    }
+                    displacement[i] = interPt.rawPoint()-points0[meshPoints[i]];
+                }
+                else
+                {
+                    Pout<< "    point:" << meshPoints[i]
+                        << " coord:" << localPoints[i]
+                        << "  did not find any intersection between ray from "
+                        << start[i]-projectVecs[i]
+                        << " to " << start[i]+projectVecs[i]
+                        << endl;
+                }
+            }
         }
     }
 
@@ -353,7 +404,7 @@ void surfaceSlipDisplacementPointPatchVectorField::evaluate
 void surfaceSlipDisplacementPointPatchVectorField::write(Ostream& os) const
 {
     pointPatchVectorField::write(os);
-    os.writeKeyword("projectSurfaces") << surfaceNames_
+    os.writeKeyword("geometry") << surfacesDict_
         << token::END_STATEMENT << nl;
     os.writeKeyword("followMode") << followModeNames_[projectMode_]
         << token::END_STATEMENT << nl;
diff --git a/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.H b/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.H
index b164795cac..5b8fca9409 100644
--- a/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.H
+++ b/src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.H
@@ -52,7 +52,7 @@ SourceFiles
 #define surfaceSlipDisplacementPointPatchVectorField_H
 
 #include "pointPatchFields.H"
-#include "triSurfaceMeshes.H"
+#include "searchableSurfaces.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -87,7 +87,7 @@ private:
         static const NamedEnum<followMode, 3> followModeNames_;
 
         //- names of surfaces
-        const fileNameList surfaceNames_;
+        const dictionary surfacesDict_;
 
         //- How to follow/project onto surface
         const followMode projectMode_;
@@ -102,7 +102,7 @@ private:
         const word frozenPointsZone_;
 
         //- Demand driven: surface to follow
-        mutable autoPtr<triSurfaceMeshes> surfacesPtr_;
+        mutable autoPtr<searchableSurfaces> surfacesPtr_;
 
 
     // Private Member Functions
@@ -187,13 +187,13 @@ public:
     // Member Functions
 
         //- Surfaces to follow
-        const fileNameList& surfaceNames() const
+        const dictionary& surfacesDict() const
         {
-            return surfaceNames_;
+            return surfacesDict_;
         }
 
         //- Surface to follow. Demand loads surfaceNames.
-        const triSurfaceMeshes& surfaces() const;
+        const searchableSurfaces& surfaces() const;
 
         //- Mode of projection/following
         followMode projectMode() const

From 76f2d62bde6d872e6c3a5ed15d271b8a28ad5d45 Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Mon, 7 Jul 2008 18:41:09 +0100
Subject: [PATCH 03/12] mesh driver rewrite; initial distributed surfaces

---
 src/autoMesh/Make/files                       |   16 +-
 .../autoHexMeshDriver/autoHexMeshDriver.C     | 1230 ++++++++---------
 .../autoHexMeshDriver/autoHexMeshDriver.H     |  145 +-
 .../autoHexMeshDriverLayers.C                 |  337 ++---
 .../autoHexMeshDriver/autoHexMeshDriverSnap.C |  224 +--
 .../layerParameters/layerParameters.C         |  213 +++
 .../layerParameters/layerParameters.H         |  246 ++++
 .../refinementParameters.C                    |  123 ++
 .../refinementParameters.H                    |  154 +++
 .../snapParameters/snapParameters.C           |   54 +
 .../snapParameters/snapParameters.H           |  129 ++
 .../meshRefinement/meshRefinement.C           |  711 ++--------
 .../meshRefinement/meshRefinement.H           |   40 +-
 .../meshRefinement/meshRefinementBaffles.C    |  434 +++---
 .../meshRefinement/meshRefinementMerge.C      |   15 -
 .../meshRefinement/meshRefinementRefine.C     |  842 ++++++-----
 .../refinementSurfaces/refinementSurfaces.C   |  989 ++++++++-----
 .../refinementSurfaces/refinementSurfaces.H   |  176 ++-
 .../autoHexMesh/shellSurfaces/shellSurfaces.C |  465 +++++++
 .../autoHexMesh/shellSurfaces/shellSurfaces.H |  182 +++
 .../trackedParticle/ExactParticle.C           |    2 +-
 .../polyTopoChange/addPatchCellLayer.C        |    4 +-
 .../polyTopoChange/addPatchCellLayer.H        |    4 +-
 src/meshTools/Make/files                      |   18 +-
 .../searchableSurface/searchableBox.C         |  541 ++++++++
 .../searchableSurface/searchableBox.H         |  249 ++++
 .../searchableSurface/searchableSphere.C      |  328 +++++
 .../searchableSurface/searchableSphere.H      |  204 +++
 .../searchableSurface/searchableSurface.C     |   43 +-
 .../searchableSurface/searchableSurface.H     |  322 +++++
 .../searchableSurface/searchableSurfaces.C    |  355 +++++
 .../searchableSurface/searchableSurfaces.H    |  187 +++
 .../searchableSurfacesQueries.C               |  822 +++++++++++
 .../searchableSurfacesQueries.H               |  198 +++
 .../searchableSurface/triSurfaceMesh.C        |  552 ++++++++
 .../searchableSurface/triSurfaceMesh.H        |  103 +-
 .../searchableSurface/searchableBox.C         |  247 ----
 .../searchableSurface/searchableBox.H         |  161 ---
 .../searchableSurface/searchableSurface.H     |  257 ----
 .../searchableSurface/triSurfaceMesh.C        |  271 ----
 .../triSurfaceMeshes/triSurfaceMeshes.C       |  916 ------------
 .../triSurfaceMeshes/triSurfaceMeshes.H       |  261 ----
 42 files changed, 7945 insertions(+), 4825 deletions(-)
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
 create mode 100644 src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.C
 create mode 100644 src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.H
 create mode 100644 src/meshTools/searchableSurface/searchableBox.C
 create mode 100644 src/meshTools/searchableSurface/searchableBox.H
 create mode 100644 src/meshTools/searchableSurface/searchableSphere.C
 create mode 100644 src/meshTools/searchableSurface/searchableSphere.H
 rename src/meshTools/{triSurface => }/searchableSurface/searchableSurface.C (65%)
 create mode 100644 src/meshTools/searchableSurface/searchableSurface.H
 create mode 100644 src/meshTools/searchableSurface/searchableSurfaces.C
 create mode 100644 src/meshTools/searchableSurface/searchableSurfaces.H
 create mode 100644 src/meshTools/searchableSurface/searchableSurfacesQueries.C
 create mode 100644 src/meshTools/searchableSurface/searchableSurfacesQueries.H
 create mode 100644 src/meshTools/searchableSurface/triSurfaceMesh.C
 rename src/meshTools/{triSurface => }/searchableSurface/triSurfaceMesh.H (64%)
 delete mode 100644 src/meshTools/triSurface/searchableSurface/searchableBox.C
 delete mode 100644 src/meshTools/triSurface/searchableSurface/searchableBox.H
 delete mode 100644 src/meshTools/triSurface/searchableSurface/searchableSurface.H
 delete mode 100644 src/meshTools/triSurface/searchableSurface/triSurfaceMesh.C
 delete mode 100644 src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.C
 delete mode 100644 src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.H

diff --git a/src/autoMesh/Make/files b/src/autoMesh/Make/files
index c562ee5c6d..1c763a316c 100644
--- a/src/autoMesh/Make/files
+++ b/src/autoMesh/Make/files
@@ -1,15 +1,21 @@
 autoHexMesh             = autoHexMesh
+autoHexMeshDriver       = $(autoHexMesh)/autoHexMeshDriver
+
+$(autoHexMeshDriver)/autoHexMeshDriver.C
+$(autoHexMeshDriver)/autoHexMeshDriverLayers.C
+$(autoHexMeshDriver)/autoHexMeshDriverShrink.C
+$(autoHexMeshDriver)/autoHexMeshDriverSnap.C
+$(autoHexMeshDriver)/layerParameters/layerParameters.C
+$(autoHexMeshDriver)/refinementParameters/refinementParameters.C
+$(autoHexMeshDriver)/snapParameters/snapParameters.C
+$(autoHexMeshDriver)/pointData/pointData.C
 
-$(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)/shellSurfaces/shellSurfaces.C
 $(autoHexMesh)/trackedParticle/trackedParticle.C
 $(autoHexMesh)/trackedParticle/trackedParticleCloud.C
 
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
index a15b422032..94c217ebcc 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
@@ -35,6 +35,9 @@ License
 #include "syncTools.H"
 #include "motionSmoother.H"
 #include "pointMesh.H"
+#include "refinementParameters.H"
+#include "snapParameters.H"
+#include "layerParameters.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -60,7 +63,8 @@ Foam::scalar Foam::autoHexMeshDriver::getMergeDistance(const scalar mergeTol)
        -scalar(IOstream::defaultPrecision())
     );
 
-    Info<< "Overall mesh bounding box  : " << meshBb << nl
+    Info<< nl
+        << "Overall mesh bounding box  : " << meshBb << nl
         << "Relative tolerance         : " << mergeTol << nl
         << "Absolute matching distance : " << mergeDist << nl
         << endl;
@@ -82,110 +86,59 @@ Foam::scalar Foam::autoHexMeshDriver::getMergeDistance(const scalar mergeTol)
 }
 
 
-// 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);
-            }
-        }
-    }
-}
+//// 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
@@ -286,324 +239,394 @@ void Foam::autoHexMeshDriver::checkCoupledFaceZones() const
 
 // * * * * * * * * * * * * * * * * 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(readScalar(dict_.lookup("mergeTolerance"))))
-{
-    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 globalRegionI = surfaces().globalRegion(surfI, i);
-
-                    // Use optionally specified patch type and name
-                    word patchType = surfaces().patchType()[globalRegionI];
-                    if (patchType == "")
-                    {
-                        patchType = wallPolyPatch::typeName;
-                    }
-
-                    word patchName = surfaces().patchName()[globalRegionI];
-                    if (patchName == "")
-                    {
-                        patchName =
-                            surfaces().names()[surfI]
-                          + '_'
-                          + regions[i].name();
-                    }
-
-                    label patchI = meshRefinement::addPatch
-                    (
-                        mesh,
-                        patchName,
-                        patchType
-                    );
-
-                    Info<< patchI << '\t' << regions[i].name() << nl;
-
-                    globalToPatch_[globalRegionI] = 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()
-        );
-    }
-}
+//// Construct from components
+//Foam::autoHexMeshDriver::autoHexMeshDriver
+//(
+//    fvMesh& mesh,
+//    const dictionary& dict,
+//    const dictionary& decomposeDict
+//)
+//:
+//    mesh_(mesh),
+//    dict_(dict),
+//    debug_(readLabel(dict_.lookup("debug"))),
+//    mergeDist_(getMergeDistance(readScalar(dict_.lookup("mergeTolerance"))))
+//{
+//    if (debug_ > 0)
+//    {
+//        meshRefinement::debug = debug_;
+//        autoHexMeshDriver::debug = debug_;
+//    }
+//
+//    refinementParameters refineParams(dict);
+//
+//    Info<< "Overall cell limit                         : "
+//        << refineParams.maxGlobalCells() << endl;
+//    Info<< "Per processor cell limit                   : "
+//        << refineParams.maxLocalCells() << endl;
+//    Info<< "Minimum number of cells to refine          : "
+//        << refineParams.minRefineCells() << endl;
+//    Info<< "Curvature                                  : "
+//        << refineParams.curvature() << nl << endl;
+//    Info<< "Layers between different refinement levels : "
+//        << refineParams.nBufferLayers() << endl;
+//
+////XXXXX
+//    PtrList<dictionary> shellsDict(dict_.lookup("refinementShells"));
+//
+//    PtrList<dictionary> surfacesDict(dict_.lookup("surfaces"));
+//
+//
+//    // Read geometry
+//    // ~~~~~~~~~~~~~
+//
+//    {
+//        Info<< "Reading all geometry." << endl;
+//
+//        // Construct dictionary with all shells and all refinement surfaces
+//        dictionary geometryDict;
+//
+//        forAll(shellsDict, shellI)
+//        {
+//            dictionary shellDict = shellsDict[shellI];
+//            const word name(shellDict.lookup("name"));
+//            shellDict.remove("name");
+//            shellDict.remove("level");
+//            shellDict.remove("refineInside");
+//            geometryDict.add(name, shellDict);
+//        }
+//
+//        forAll(surfacesDict, surfI)
+//        {
+//            dictionary surfDict = surfacesDict[shellI];
+//            const word name(string::validate<word>(surfDict.lookup("file")));
+//            surfDict.remove("file");
+//            if (!surfDict.found("name"))
+//            {
+//                surfDict.add("name", name);
+//            }
+//            geometryDict.add(name, iter());
+//        }
+//
+//        allGeometryPtr_.reset
+//        (
+//            new searchableSurfaces
+//            (
+//                IOobject
+//                (
+//                    "abc",                      // dummy name
+//                    mesh_.time().constant(),    // directory
+//                    "triSurface",               // instance
+//                    mesh_.time(),               // registry
+//                    IOobject::MUST_READ,
+//                    IOobject::NO_WRITE
+//                ),
+//                geometryDict
+//            )
+//        );
+//
+//        Info<< "Read geometry in = "
+//            << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+//    }
+//
+//
+//    // Read refinement surfaces
+//    // ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+//    {
+//        Info<< "Reading surfaces and constructing search trees." << endl;
+//
+//        surfacesPtr_.reset
+//        (
+//            new refinementSurfaces
+//            (
+//                allGeometryPtr_(),
+//                surfacesDict
+//            )
+//        );
+//        Info<< "Read surfaces in = "
+//            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+//    }
+//
+//    // 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 globalRegionI = surfaces().globalRegion(surfI, i);
+//
+//                    // Use optionally specified patch type and name
+//                    word patchType = surfaces().patchType()[globalRegionI];
+//                    if (patchType == "")
+//                    {
+//                        patchType = wallPolyPatch::typeName;
+//                    }
+//
+//                    word patchName = surfaces().patchName()[globalRegionI];
+//                    if (patchName == "")
+//                    {
+//                        patchName =
+//                            surfaces().names()[surfI]
+//                          + '_'
+//                          + regions[i].name();
+//                    }
+//
+//                    label patchI = meshRefinement::addPatch
+//                    (
+//                        mesh,
+//                        patchName,
+//                        patchType
+//                    );
+//
+//                    Info<< patchI << '\t' << regions[i].name() << nl;
+//
+//                    globalToPatch_[globalRegionI] = 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()
+//        );
+//    }
+//}
 
 
 // Construct from separate dictionaries.
@@ -611,6 +634,7 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
 (
     fvMesh& mesh,
     const dictionary& controlDict,
+    const dictionary& geometryDict,
     const dictionary& refineDict,
     const dictionary& decomposeDict
 )
@@ -618,15 +642,9 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
     mesh_(mesh),
     dict_(controlDict),
     debug_(readLabel(controlDict.lookup("debug"))),
-    maxGlobalCells_(readLabel(refineDict.lookup("cellLimit"))),
-    maxLocalCells_(readLabel(refineDict.lookup("procCellLimit"))),
-    minRefineCells_(readLabel(refineDict.lookup("minimumRefine"))),
-    curvature_(readScalar(refineDict.lookup("curvature"))),
-    nBufferLayers_(readLabel(refineDict.lookup("nBufferLayers"))),
-    keepPoints_(refineDict.lookup("keepPoints")),
     mergeDist_
     (
-        getMergeDistance(readScalar(refineDict.lookup("mergeTolerance")))
+        getMergeDistance(readScalar(controlDict.lookup("mergeTolerance")))
     )
 {
     if (debug_ > 0)
@@ -635,127 +653,69 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
         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;
+    // Read geometry
+    // ~~~~~~~~~~~~~
 
-    // Check keepPoints are sensible
-    findCells(keepPoints_);
-
-
-    // Read refinement shells
-    // ~~~~~~~~~~~~~~~~~~~~~~
-
-    {
-        Info<< "Reading refinement shells." << endl;
-
-        PtrList<dictionary> shellDicts(refineDict.lookup("refinementShells"));
-
-        shells_.setSize(shellDicts.size());
-        shellLevels_.setSize(shellDicts.size());
-        shellRefineInside_.setSize(shellDicts.size());
-
-        forAll(shellDicts, i)
-        {
-            const dictionary& dict = shellDicts[i];
-
-            shells_.set
+    Info<< "Reading all geometry." << endl;
+    allGeometryPtr_.reset
+    (
+        new searchableSurfaces
+        (
+            IOobject
             (
-                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;
-    }
+                "abc",                      // dummy name
+                mesh_.time().constant(),    // directory
+                "triSurface",               // instance
+                mesh_.time(),               // registry
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            geometryDict
+        )
+    );
+    Info<< "Read geometry in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
 
 
     // Read refinement surfaces
     // ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    {
-        Info<< "Reading surfaces and constructing search trees." << endl;
-
-        surfacesPtr_.reset
+    Info<< "Reading refinement surfaces." << endl;
+    surfacesPtr_.reset
+    (
+        new refinementSurfaces
         (
-            new refinementSurfaces
-            (
-                IOobject
-                (
-                    "",                                 // dummy name
-                    mesh_.time().constant(),            // directory
-                    "triSurface",                       // instance
-                    mesh_.time(),                       // registry
-                    IOobject::MUST_READ,
-                    IOobject::NO_WRITE
-                ),
-                refineDict.lookup("surfaces")
-            )
-        );
-        Info<< "Read surfaces in = "
-            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+            allGeometryPtr_(),
+            refineDict.subDict("refinementSurfaces")
+        )
+    );
+    Info<< "Read refinement surfaces in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << nl << 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
+    // Read refinement shells
+    // ~~~~~~~~~~~~~~~~~~~~~~
+
+    Info<< "Reading refinement shells." << endl;
+    shellsPtr_.reset
+    (
+        new shellSurfaces
         (
-            shells_,
-            shellLevels_,
-            shellRefineInside_
-        );
-        Info<< "Checked shell refinement in = "
-            << mesh_.time().cpuTimeIncrement() << " s" << endl;
-    }
+            allGeometryPtr_(),
+            refineDict.subDict("refinementRegions")
+        )
+    );
+    Info<< "Read refinement shells in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
+    Info<< "Setting refinement level of surface to be consistent"
+        << " with shells." << endl;
+    surfacesPtr_().setMinLevelFields(shells());
+    Info<< "Checked shell refinement in = "
+        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
 
     // Check faceZones are synchronised
     checkCoupledFaceZones();
@@ -777,38 +737,41 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
             << "-----\t------"
             << endl;
 
-        forAll(surfaces(), surfI)
+        const labelList& surfaceGeometry = surfaces().surfaces();
+        forAll(surfaceGeometry, surfI)
         {
-            const triSurfaceMesh& s = surfaces()[surfI];
+            label geomI = surfaceGeometry[surfI];
+
+            const wordList& regNames = allGeometryPtr_().regionNames()[geomI];
 
             Info<< surfaces().names()[surfI] << ':' << nl << nl;
 
-            const geometricSurfacePatchList& regions = s.patches();
+            //const triSurfaceMesh& s = surfaces()[surfI];
+            //const geometricSurfacePatchList& regions = s.patches();
+            //labelList nTrisPerRegion(surfaces().countRegions(s));
 
-            labelList nTrisPerRegion(surfaces().countRegions(s));
-
-            forAll(regions, i)
+            forAll(regNames, i)
             {
-                if (nTrisPerRegion[i] > 0)
-                {
+                //if (nTrisPerRegion[i] > 0)
+                //{
                     label patchI = meshRefinement::addPatch
                     (
                         mesh,
                         //s.searchableSurface::name() + '_' + regions[i].name(),
-                        surfaces().names()[surfI] + '_' + regions[i].name(),
+                        regNames[i],
                         wallPolyPatch::typeName
                     );
 
-                    Info<< patchI << '\t' << regions[i].name() << nl;
+                    Info<< patchI << '\t' << regNames[i] << nl;
 
                     globalToPatch_[surfaces().globalRegion(surfI, i)] = patchI;
-                }
+                //}
             }
 
             Info<< nl;
         }
         Info<< "Added patches in = "
-            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+            << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
     }
 
     // Parallel
@@ -855,11 +818,12 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
             (
                 mesh,
                 mergeDist_,         // tolerance used in sorting coordinates
-                surfaces()
+                surfaces(),         // for surface intersection refinement
+                shells()            // for volume (inside/outside) refinement
             )
         );
         Info<< "Calculated surface intersections in = "
-            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+            << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
 
         // Some stats
         meshRefinerPtr_().printMeshInfo(debug_, "Initial mesh");
@@ -920,7 +884,7 @@ Foam::label Foam::autoHexMeshDriver::readFeatureEdges
     }
 
     Info<< "Read feature lines in = "
-        << mesh_.time().cpuTimeIncrement() << " s" << endl;
+        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
 
     return featureMeshes_.size();
 }
@@ -928,6 +892,7 @@ Foam::label Foam::autoHexMeshDriver::readFeatureEdges
 
 Foam::label Foam::autoHexMeshDriver::featureEdgeRefine
 (
+    const refinementParameters& refineParams,
     const PtrList<dictionary>& featDicts,
     const label maxIter,
     const label minRefine
@@ -953,23 +918,18 @@ Foam::label Foam::autoHexMeshDriver::featureEdgeRefine
             (
                 meshRefiner.refineCandidates
                 (
-                    keepPoints_[0],     // For now only use one.
-                    globalToPatch_,
-                    curvature_,
+                    refineParams.keepPoints()[0],    // For now only use one.
+                    refineParams.curvature(),
 
                     featureMeshes_,
                     featureLevels_,
 
-                    shells_,
-                    shellLevels_,
-                    shellRefineInside_,
-
                     true,               // featureRefinement
                     false,              // internalRefinement
                     false,              // surfaceRefinement
                     false,              // curvatureRefinement
-                    maxGlobalCells_,
-                    maxLocalCells_
+                    refineParams.maxGlobalCells(),
+                    refineParams.maxLocalCells()
                 )
             );
             labelList cellsToRefine
@@ -1018,7 +978,11 @@ Foam::label Foam::autoHexMeshDriver::featureEdgeRefine
 }
 
 
-Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine(const label maxIter)
+Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine
+(
+    const refinementParameters& refineParams,
+    const label maxIter
+)
 {
     meshRefinement& meshRefiner = meshRefinerPtr_();
 
@@ -1044,23 +1008,18 @@ Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine(const label maxIter)
         (
             meshRefiner.refineCandidates
             (
-                keepPoints_[0],
-                globalToPatch_,
-                curvature_,
+                refineParams.keepPoints()[0],
+                refineParams.curvature(),
 
                 featureMeshes_,
                 featureLevels_,
 
-                shells_,
-                shellLevels_,
-                shellRefineInside_,
-
                 false,              // featureRefinement
                 false,              // internalRefinement
                 true,               // surfaceRefinement
                 true,               // curvatureRefinement
-                maxGlobalCells_,
-                maxLocalCells_
+                refineParams.maxGlobalCells(),
+                refineParams.maxLocalCells()
             )
         );
         labelList cellsToRefine
@@ -1089,7 +1048,7 @@ Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine(const label maxIter)
             nCellsToRefine == 0
          || (
                 iter >= overallMaxLevel
-             && nCellsToRefine <= minRefineCells_
+             && nCellsToRefine <= refineParams.minRefineCells()
             )
         )
         {
@@ -1116,7 +1075,11 @@ Foam::label Foam::autoHexMeshDriver::surfaceOnlyRefine(const label maxIter)
 }
 
 
-void Foam::autoHexMeshDriver::removeInsideCells(const label nBufferLayers)
+void Foam::autoHexMeshDriver::removeInsideCells
+(
+    const refinementParameters& refineParams,
+    const label nBufferLayers
+)
 {
 
     meshRefinement& meshRefiner = meshRefinerPtr_();
@@ -1135,7 +1098,7 @@ void Foam::autoHexMeshDriver::removeInsideCells(const label nBufferLayers)
     (
         nBufferLayers,                  // nBufferLayers
         globalToPatch_,
-        keepPoints_[0]
+        refineParams.keepPoints()[0]
     );
 
     if (debug_)
@@ -1149,7 +1112,11 @@ void Foam::autoHexMeshDriver::removeInsideCells(const label nBufferLayers)
 }
 
 
-Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
+Foam::label Foam::autoHexMeshDriver::shellRefine
+(
+    const refinementParameters& refineParams,
+    const label maxIter
+)
 {
     meshRefinement& meshRefiner = meshRefinerPtr_();
 
@@ -1170,15 +1137,7 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
     // 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 overallMaxShellLevel = shells().maxLevel();
 
     label iter;
     for (iter = 0; iter < maxIter; iter++)
@@ -1192,23 +1151,18 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
         (
             meshRefiner.refineCandidates
             (
-                keepPoints_[0],
-                globalToPatch_,
-                curvature_,
+                refineParams.keepPoints()[0],
+                refineParams.curvature(),
 
                 featureMeshes_,
                 featureLevels_,
 
-                shells_,
-                shellLevels_,
-                shellRefineInside_,
-
                 false,              // featureRefinement
                 true,               // internalRefinement
                 false,              // surfaceRefinement
                 false,              // curvatureRefinement
-                maxGlobalCells_,
-                maxLocalCells_
+                refineParams.maxGlobalCells(),
+                refineParams.maxLocalCells()
             )
         );
 
@@ -1232,16 +1186,16 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
             findIndices(meshRefiner.userFaceData()[0].second(), 0)
         );
 
-        Info<< "Collected boundary faces : "
-            << returnReduce(bFaces.size(), sumOp<label>()) << endl;
+        //Info<< "Collected boundary faces : "
+        //    << returnReduce(bFaces.size(), sumOp<label>()) << endl;
 
         labelList cellsToRefine;
 
-        if (nBufferLayers_ <= 2)
+        if (refineParams.nBufferLayers() <= 2)
         {
             cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement
             (
-                nBufferLayers_,
+                refineParams.nBufferLayers(),
                 candidateCells,                 // cells to refine
                 bFaces,                         // faces for nBufferLayers
                 1,                              // point difference
@@ -1252,7 +1206,7 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
         {
             cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement2
             (
-                nBufferLayers_,
+                refineParams.nBufferLayers(),
                 candidateCells,                 // cells to refine
                 bFaces                          // faces for nBufferLayers
             );
@@ -1276,7 +1230,7 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
             nCellsToRefine == 0
          || (
                 iter >= overallMaxShellLevel
-             && nCellsToRefine <= minRefineCells_
+             && nCellsToRefine <= refineParams.minRefineCells()
             )
         )
         {
@@ -1305,7 +1259,11 @@ Foam::label Foam::autoHexMeshDriver::shellRefine(const label maxIter)
 }
 
 
-void Foam::autoHexMeshDriver::baffleAndSplitMesh(const bool handleSnapProblems)
+void Foam::autoHexMeshDriver::baffleAndSplitMesh
+(
+    const refinementParameters& refineParams,
+    const bool handleSnapProblems
+)
 {
     meshRefinement& meshRefiner = meshRefinerPtr_();
 
@@ -1323,12 +1281,15 @@ void Foam::autoHexMeshDriver::baffleAndSplitMesh(const bool handleSnapProblems)
         !handleSnapProblems,            // merge free standing baffles?
         const_cast<Time&>(mesh_.time()),
         globalToPatch_,
-        keepPoints_[0]
+        refineParams.keepPoints()[0]
     );
 }
 
 
-void Foam::autoHexMeshDriver::zonify()
+void Foam::autoHexMeshDriver::zonify
+(
+    const refinementParameters& refineParams
+)
 {
     // Mesh is at its finest. Do zoning
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1351,7 +1312,7 @@ void Foam::autoHexMeshDriver::zonify()
             const_cast<Time&>(mesh_.time())++;
         }
 
-        meshRefiner.zonify(keepPoints_[0]);
+        meshRefiner.zonify(refineParams.keepPoints()[0]);
 
         if (debug_)
         {
@@ -1372,6 +1333,7 @@ void Foam::autoHexMeshDriver::zonify()
 
 void Foam::autoHexMeshDriver::splitAndMergeBaffles
 (
+    const refinementParameters& refineParams,
     const bool handleSnapProblems
 )
 {
@@ -1394,7 +1356,7 @@ void Foam::autoHexMeshDriver::splitAndMergeBaffles
         false,                  // merge free standing baffles?
         const_cast<Time&>(mesh_.time()),
         globalToPatch_,
-        keepPoints_[0]
+        refineParams.keepPoints()[0]
     );
 
     if (debug_)
@@ -1447,7 +1409,10 @@ void Foam::autoHexMeshDriver::splitAndMergeBaffles
 }
 
 
-void Foam::autoHexMeshDriver::mergePatchFaces()
+void Foam::autoHexMeshDriver::mergePatchFaces
+(
+    const refinementParameters& refineParams
+)
 {
     Info<< nl
         << "Merge refined boundary faces" << nl
@@ -1536,8 +1501,8 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::autoHexMeshDriver::balance
                 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'.
+                // Get faces whose owner and neighbour should stay together,
+                // i.e. they are not 'blocked'.
 
                 label nZoned = 0;
 
@@ -1655,11 +1620,18 @@ void Foam::autoHexMeshDriver::doRefine
 
     const_cast<Time&>(mesh_.time())++;
 
+    // Get all the refinement specific params
+    refinementParameters refineParams(refineDict);
+
+    // Check that all the keep points are inside the mesh.
+    refineParams.findCells(mesh_);
+
     PtrList<dictionary> featDicts(refineDict.lookup("features"));
 
     // Refine around feature edges
     featureEdgeRefine
     (
+        refineParams,
         featDicts,
         100,    // maxIter
         0       // min cells to refine
@@ -1668,34 +1640,37 @@ void Foam::autoHexMeshDriver::doRefine
     // Refine based on surface
     surfaceOnlyRefine
     (
+        refineParams,
         100     // maxIter
     );
 
     // Remove cells (a certain distance) beyond surface intersections
     removeInsideCells
     (
+        refineParams,
         1       // nBufferLayers
     );
 
     // Internal mesh refinement
     shellRefine
     (
+        refineParams,
         100    // maxIter
     );
 
     // Introduce baffles at surface intersections
-    baffleAndSplitMesh(prepareForSnapping);
+    baffleAndSplitMesh(refineParams, prepareForSnapping);
 
     // Mesh is at its finest. Do optional zoning.
-    zonify();
+    zonify(refineParams);
 
     // Pull baffles apart
-    splitAndMergeBaffles(prepareForSnapping);
+    splitAndMergeBaffles(refineParams, prepareForSnapping);
 
     // Do something about cells with refined faces on the boundary
     if (prepareForSnapping)
     {
-        mergePatchFaces();
+        mergePatchFaces(refineParams);
     }
 
     // Do final balancing. Keep zoned faces on one processor.
@@ -1719,6 +1694,9 @@ void Foam::autoHexMeshDriver::doSnap
 
     const_cast<Time&>(mesh_.time())++;
 
+    // Get all the snapping specific params
+    snapParameters snapParams(snapDict);
+
     // Get the labels of added patches.
     labelList adaptPatchIDs(getSurfacePatches());
 
@@ -1739,7 +1717,7 @@ void Foam::autoHexMeshDriver::doSnap
         indirectPrimitivePatch& pp = ppPtr();
 
         // Distance to attact to nearest feature on surface
-        const scalarField snapDist(calcSnapDistance(snapDict, pp));
+        const scalarField snapDist(calcSnapDistance(snapParams, pp));
 
 
         // Construct iterative mesh mover.
@@ -1777,17 +1755,17 @@ void Foam::autoHexMeshDriver::doSnap
             << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
 
         // Pre-smooth patch vertices (so before determining nearest)
-        preSmoothPatch(snapDict, nInitErrors, baffles, meshMover);
+        preSmoothPatch(snapParams, nInitErrors, baffles, meshMover);
 
         // Calculate displacement at every patch point. Insert into
         // meshMover.
         calcNearestSurface(snapDist, meshMover);
 
         // Get smoothly varying internal displacement field.
-        smoothDisplacement(snapDict, meshMover);
+        smoothDisplacement(snapParams, meshMover);
 
         // Apply internal displacement to mesh.
-        scaleMesh(snapDict, nInitErrors, baffles, meshMover);
+        scaleMesh(snapParams, nInitErrors, baffles, meshMover);
     }
 
     // Merge any introduced baffles.
@@ -1811,22 +1789,24 @@ void Foam::autoHexMeshDriver::doLayers
 
     const_cast<Time&>(mesh_.time())++;
 
+    // Get all the layer specific params
+    layerParameters layerParams(shrinkDict, mesh_.boundaryMesh());
+
     Info<< "Using mesh parameters " << motionDict << nl << endl;
 
     // Merge coplanar boundary faces
-    mergePatchFacesUndo(shrinkDict, motionDict);
+    mergePatchFacesUndo(layerParams, motionDict);
 
-    // Per global region the number of layers (0 if no layer)
-    const labelList& numLayers = surfaces().numLayers();
+    // Per patch the number of layers (0 if no layer)
+    const labelList& numLayers = layerParams.numLayers();
 
     // Patches that need to get a layer
     DynamicList<label> patchIDs(numLayers.size());
     label nFacesWithLayers = 0;
-    forAll(numLayers, region)
+    forAll(numLayers, patchI)
     {
-        if (numLayers[region] > 0 && globalToPatch()[region] != -1)
+        if (numLayers[patchI] > 0)
         {
-            label patchI = globalToPatch()[region];
             patchIDs.append(patchI);
             nFacesWithLayers += mesh_.boundaryMesh()[patchI].size();
         }
@@ -1882,7 +1862,7 @@ void Foam::autoHexMeshDriver::doLayers
                 << endl;
 
             // Do all topo changes
-            addLayers(shrinkDict, motionDict, nInitErrors, meshMover);
+            addLayers(layerParams, motionDict, nInitErrors, meshMover);
         }
 
         // Write mesh.
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
index 28a4845b9a..06d377a277 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
@@ -49,8 +49,9 @@ SourceFiles
 #include "wallPoint.H"
 #include "indirectPrimitivePatch.H"
 #include "featureEdgeMesh.H"
-#include "searchableSurface.H"
+#include "searchableSurfaces.H"
 #include "refinementSurfaces.H"
+#include "shellSurfaces.H"
 #include "meshRefinement.H"
 #include "decompositionMethod.H"
 #include "fvMeshDistribute.H"
@@ -70,6 +71,9 @@ class pointData;
 class faceSet;
 class addPatchCellLayer;
 class mapDistributePolyMesh;
+class snapParameters;
+class layerParameters;
+class refinementParameters;
 
 /*---------------------------------------------------------------------------*\
                            Class autoHexMeshDriver Declaration
@@ -79,15 +83,13 @@ 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 */
+            EXTRUDEREMOVE   /*!< Extrude but afterwards remove added */
+                            /*!< faces locally */
         };
 
 
@@ -141,42 +143,24 @@ class autoHexMeshDriver
         //- 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_;
 
 
+        // Refinement only
 
-        //- Explicit features
-        PtrList<featureEdgeMesh> featureMeshes_;
-        //- Per feature the refinement level
-        labelList featureLevels_;
+            //- 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_;
+        //- All surface based geometry
+        autoPtr<searchableSurfaces> allGeometryPtr_;
 
-        //- Surfaces with refinement levels built-in
+        //- Shells (geometry for inside/outside refinement)
+        autoPtr<shellSurfaces> shellsPtr_;
+
+        //- Surfaces (geometry for intersection based refinement)
         autoPtr<refinementSurfaces> surfacesPtr_;
 
         //- Per refinement surface region the patch
@@ -200,10 +184,6 @@ class autoHexMeshDriver
             //- Calculate merge distance. Check against writing tolerance.
             scalar getMergeDistance(const scalar mergeTol) 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
@@ -371,6 +351,7 @@ class autoHexMeshDriver
                 //  layers per surface.
                 void setNumLayers
                 (
+                    const labelList& patchToNLayers,
                     const labelList& patchIDs,
                     const indirectPrimitivePatch& pp,
                     pointField& patchDisp,
@@ -390,17 +371,22 @@ class autoHexMeshDriver
                 //- Calculate pointwise wanted and minimum thickness.
                 //  thickness: wanted thickness
                 //  minthickness: when to give up and not extrude
+                //  Gets per patch parameters and determine pp pointwise
+                //  parameters.
                 void calculateLayerThickness
                 (
-                    const scalar expansionRatio,
-                    const scalar finalLayerRatio,
-                    const scalar relMinThickness,
                     const indirectPrimitivePatch& pp,
+                    const labelList& patchIDs,
+                    const scalarField& patchExpansionRatio,
+                    const scalarField& patchFinalLayerRatio,
+                    const scalarField& patchRelMinThickness,
                     const labelList& cellLevel,
                     const labelList& patchNLayers,
                     const scalar edge0Len,
+
                     scalarField& thickness,
-                    scalarField& minThickness
+                    scalarField& minThickness,
+                    scalarField& expansionRatio
                 ) const;
 
 
@@ -638,13 +624,13 @@ public:
 
     // Constructors
 
-        //- Construct from dictionary and mesh to modify
-        autoHexMeshDriver
-        (
-            fvMesh& mesh,
-            const dictionary& meshDict,
-            const dictionary& decomposeDict
-        );
+//        //- Construct from dictionary and mesh to modify
+//        autoHexMeshDriver
+//        (
+//            fvMesh& mesh,
+//            const dictionary& meshDict,
+//            const dictionary& decomposeDict
+//        );
 
         //- Alternative constructor from top-level controldictionary and
         //  refinement specific dictionary
@@ -652,6 +638,7 @@ public:
         (
             fvMesh& mesh,
             const dictionary& controlDict,
+            const dictionary& geometryDict,
             const dictionary& refineDict,
             const dictionary& decomposeDict
         );
@@ -677,6 +664,12 @@ public:
                 return surfacesPtr_();
             }
 
+            //- Surfaces to volume refinement on
+            const shellSurfaces& shells() const
+            {
+                return shellsPtr_();
+            }
+
             //- Per refinementsurface, per region the patch
             const labelList& globalToPatch() const
             {
@@ -689,32 +682,53 @@ public:
             //- Refine around explicit feature edges
             label featureEdgeRefine
             (
+                const refinementParameters& refineParams,
                 const PtrList<dictionary>& featDicts,
                 const label maxIter,
                 const label minRefine
             );
 
             //- Refine at surface intersections
-            label surfaceOnlyRefine(const label maxIter);
+            label surfaceOnlyRefine
+            (
+                const refinementParameters& refineParams,
+                const label maxIter
+            );
 
             //- Remove cells not reachable from keep points
-            void removeInsideCells(const label nBufferLayers);
+            void removeInsideCells
+            (    
+                const refinementParameters& refineParams,
+                const label nBufferLayers
+            );
 
             //- Refine volume regions (interior of shells)
-            label shellRefine(const label maxIter);
+            label shellRefine
+            (
+                const refinementParameters& refineParams,
+                const label maxIter
+            );
 
             //- Introduce baffles; remove unreachable mesh parts
             //  handleSnapProblems : whether to remove free floating cells
-            void baffleAndSplitMesh(const bool handleSnapProblems);
+            void baffleAndSplitMesh
+            (
+                const refinementParameters& refineParams,
+                const bool handleSnapProblems
+            );
 
             //- Move cells to zones
-            void zonify();
+            void zonify(const refinementParameters&);
 
             //- Split and recombine baffles to get rid of single face baffles.
-            void splitAndMergeBaffles(const bool handleSnapProblems);
+            void splitAndMergeBaffles
+            (
+                const refinementParameters& refineParams,
+                const bool handleSnapProblems
+            );
 
             //- Merge multiple boundary faces on single cell
-            void mergePatchFaces();
+            void mergePatchFaces(const refinementParameters&);
 
             //- Redecompose according to cell count
             //  keepZoneFaces : find all faceZones from zoned surfaces and keep
@@ -742,7 +756,7 @@ public:
             //- Calculate edge length per patch point.
             scalarField calcSnapDistance
             (
-                const dictionary& snapDict,
+                const snapParameters& snapParams,
                 const indirectPrimitivePatch&
             ) const;
 
@@ -753,12 +767,19 @@ public:
             //  of surface points (on castellated mesh) w.r.t. surface.
             void preSmoothPatch
             (
-                const dictionary& snapDict,
+                const snapParameters& snapParams,
                 const label nInitErrors,
                 const List<labelPair>& baffles,
                 motionSmoother&
             ) const;
 
+            //- Get points both on patch and facezone.
+            labelList getZoneSurfacePoints
+            (
+                const indirectPrimitivePatch&,
+                const word& zoneName
+            ) const;
+
             //- Per patch point calculate point on nearest surface. Set as
             //  boundary conditions of motionSmoother displacement field. Return
             //  displacement of patch points.
@@ -771,7 +792,7 @@ public:
             //- Smooth the displacement field to the internal.
             void smoothDisplacement
             (
-                const dictionary& snapDict,
+                const snapParameters& snapParams,
                 motionSmoother&
             ) const;
 
@@ -779,7 +800,7 @@ public:
             //  locally relax the displacement.
             void scaleMesh
             (
-                const dictionary& snapDict,
+                const snapParameters& snapParams,
                 const label nInitErrors,
                 const List<labelPair>& baffles,
                 motionSmoother&
@@ -791,7 +812,7 @@ public:
             //- Merge patch faces on same cell.
             void mergePatchFacesUndo
             (
-                const dictionary& shrinkDict,
+                const layerParameters& layerParams,
                 const dictionary& motionDict
             );
 
@@ -801,7 +822,7 @@ public:
             //- Add cell layers
             void addLayers
             (
-                const dictionary& shrinkDict,
+                const layerParameters& layerParams,
                 const dictionary& motionDict,
                 const label nAllowableErrors,
                 motionSmoother&
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
index 0615d50476..3ebf41390c 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
@@ -27,7 +27,6 @@ Description
 
 \*----------------------------------------------------------------------------*/
 
-#include "ListOps.H"
 #include "autoHexMeshDriver.H"
 #include "fvMesh.H"
 #include "Time.H"
@@ -43,11 +42,8 @@ Description
 #include "mapPolyMesh.H"
 #include "addPatchCellLayer.H"
 #include "mapDistributePolyMesh.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-const Foam::scalar Foam::autoHexMeshDriver::defaultConcaveAngle = 90;
-
+#include "OFstream.H"
+#include "layerParameters.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -1191,6 +1187,7 @@ void Foam::autoHexMeshDriver::handleWarpedFaces
 // No extrusion on faces with differing number of layers for points
 void Foam::autoHexMeshDriver::setNumLayers
 (
+    const labelList& patchToNLayers,
     const labelList& patchIDs,
     const indirectPrimitivePatch& pp,
     pointField& patchDisp,
@@ -1201,18 +1198,6 @@ void Foam::autoHexMeshDriver::setNumLayers
     Info<< nl << "Handling points with inconsistent layer specification ..."
         << endl;
 
-    const labelList& nSurfLayers = surfaces().numLayers();
-
-    // Build map from patch to layers
-    Map<label> patchToNLayers(nSurfLayers.size());
-    forAll(nSurfLayers, region)
-    {
-        if (globalToPatch_[region] != -1)
-        {
-            patchToNLayers.insert(globalToPatch_[region], nSurfLayers[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);
@@ -1257,7 +1242,7 @@ void Foam::autoHexMeshDriver::setNumLayers
     // Unmark any point with different min and max
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    label nConflicts = 0;
+    //label nConflicts = 0;
 
     forAll(maxLayers, i)
     {
@@ -1294,11 +1279,11 @@ void Foam::autoHexMeshDriver::setNumLayers
         }
     }
 
-    reduce(nConflicts, sumOp<label>());
-
-    Info<< "Set displacement to zero for " << nConflicts
-        << " points due to points being on multiple regions"
-        << " with inconsistent nLayers specification." << endl;
+    //reduce(nConflicts, sumOp<label>());
+    //
+    //Info<< "Set displacement to zero for " << nConflicts
+    //    << " points due to points being on multiple regions"
+    //    << " with inconsistent nLayers specification." << endl;
 }
 
 
@@ -1369,59 +1354,137 @@ void Foam::autoHexMeshDriver::growNoExtrusion
 }
 
 
-
-// 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& patchIDs,
+    const scalarField& patchExpansionRatio,
+    const scalarField& patchFinalLayerRatio,
+    const scalarField& patchRelMinThickness,
     const labelList& cellLevel,
     const labelList& patchNLayers,
     const scalar edge0Len,
+
     scalarField& thickness,
-    scalarField& minThickness
+    scalarField& minThickness,
+    scalarField& expansionRatio
 ) const
 {
-    if (relMinThickness < 0 || relMinThickness > 2)
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    if (min(patchRelMinThickness) < 0 || max(patchRelMinThickness) > 2)
     {
         FatalErrorIn("calculateLayerThickness(..)")
             << "Thickness should be factor of local undistorted cell size."
             << " Valid values are [0..2]." << nl
-            << " minThickness:" << relMinThickness
+            << " minThickness:" << patchRelMinThickness
             << 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)
+        forAll(pp, i)
         {
-            maxPointLevel[f[fp]] = max(maxPointLevel[f[fp]], ownLevel);
+            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
+        );
     }
 
-    syncTools::syncPointList
-    (
-        mesh_,
-        pp.meshPoints(),
-        maxPointLevel,
-        maxEqOp<label>(),
-        labelMin,           // null value
-        false               // no separation
-    );
 
+    // Rework patch-wise layer parameters into minimum per point
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    expansionRatio.setSize(pp.nPoints());
+    expansionRatio = GREAT;
+    scalarField finalLayerRatio(pp.nPoints(), GREAT);
+    scalarField relMinThickness(pp.nPoints(), GREAT);
+
+    {
+        forAll(patchIDs, i)
+        {
+            label patchI = patchIDs[i];
+
+            const labelList& meshPoints = patches[patchI].meshPoints();
+
+            forAll(meshPoints, patchPointI)
+            {
+                label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
+
+                expansionRatio[ppPointI] = min
+                (
+                    expansionRatio[ppPointI],
+                    patchExpansionRatio[patchI]
+                );
+                finalLayerRatio[ppPointI] = min
+                (
+                    finalLayerRatio[ppPointI],
+                    patchFinalLayerRatio[patchI]
+                );
+                relMinThickness[ppPointI] = min
+                (
+                    relMinThickness[ppPointI],
+                    patchRelMinThickness[patchI]
+                );
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh_,
+            pp.meshPoints(),
+            expansionRatio,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+        syncTools::syncPointList
+        (
+            mesh_,
+            pp.meshPoints(),
+            finalLayerRatio,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+        syncTools::syncPointList
+        (
+            mesh_,
+            pp.meshPoints(),
+            relMinThickness,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+    }
+
+
+
+    // Per mesh point the expansion parameters
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    thickness.setSize(pp.nPoints());
+    minThickness.setSize(pp.nPoints());
 
     forAll(maxPointLevel, pointI)
     {
@@ -1430,19 +1493,24 @@ void Foam::autoHexMeshDriver::calculateLayerThickness
 
         // Calculate layer thickness based on expansion ratio
         // and final layer height
-        if (expansionRatio == 1)
+        if (expansionRatio[pointI] == 1)
         {
-            thickness[pointI] = finalLayerRatio*patchNLayers[pointI]*edgeLen;
-            minThickness[pointI] = relMinThickness*edgeLen;
+            thickness[pointI] =
+                finalLayerRatio[pointI]
+              * patchNLayers[pointI]
+              * edgeLen;
+            minThickness[pointI] = relMinThickness[pointI]*edgeLen;
         }
         else
         {
-            scalar invExpansion = 1.0 / expansionRatio;
+            scalar invExpansion = 1.0 / expansionRatio[pointI];
             label nLay = patchNLayers[pointI];
-            thickness[pointI] = finalLayerRatio*edgeLen
-                * (1.0 - pow(invExpansion, nLay))
-                / (1.0 - invExpansion);
-            minThickness[pointI] = relMinThickness*edgeLen;
+            thickness[pointI] =
+                finalLayerRatio[pointI]
+              * edgeLen
+              * (1.0 - pow(invExpansion, nLay))
+              / (1.0 - invExpansion);
+            minThickness[pointI] = relMinThickness[pointI]*edgeLen;
         }
     }
 
@@ -2309,31 +2377,34 @@ void Foam::autoHexMeshDriver::getLayerCellsFaces
 
 void Foam::autoHexMeshDriver::mergePatchFacesUndo
 (
-    const dictionary& shrinkDict,
+    const layerParameters& layerParams,
     const dictionary& motionDict
 )
 {
-    const scalar featureAngle(readScalar(shrinkDict.lookup("featureAngle")));
-    scalar minCos = Foam::cos(featureAngle*mathematicalConstant::pi/180.0);
+    scalar minCos = Foam::cos
+    (
+        layerParams.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);
+    scalar concaveCos = Foam::cos
+    (
+        layerParams.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"
+        << "    - which make an angle < " << layerParams.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
+        << layerParams.concaveAngle()
+        << " degrees (0=straight, 180=fully concave)" << nl
         << endl;
 
     label nChanged = mergePatchFacesUndo(minCos, concaveCos, motionDict);
@@ -2344,80 +2415,18 @@ void Foam::autoHexMeshDriver::mergePatchFacesUndo
 
 void Foam::autoHexMeshDriver::addLayers
 (
-    const dictionary& shrinkDict,
+    const layerParameters& layerParams,
     const dictionary& motionDict,
     const label nAllowableErrors,
     motionSmoother& meshMover
 )
 {
-    // Read some more dictionary settings
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // 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();
 
+    // Precalculate mesh edge labels for patch edges
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
     labelList meshEdges(pp.nEdges());
     forAll(pp.edges(), edgeI)
     {
@@ -2449,8 +2458,9 @@ void Foam::autoHexMeshDriver::addLayers
 
     setNumLayers
     (
-        meshMover.adaptPatchIDs(),
-        pp,
+        layerParams.numLayers(),    // per patch the num layers
+        meshMover.adaptPatchIDs(),  // patches that are being moved
+        pp,                         // indirectpatch for all faces moving
 
         patchDisp,
         patchNLayers,
@@ -2477,7 +2487,7 @@ void Foam::autoHexMeshDriver::addLayers
     (
         pp,
         meshEdges,
-        minCos,
+        layerParams.featureAngle()*mathematicalConstant::pi/180.0,
 
         patchDisp,
         patchNLayers,
@@ -2494,7 +2504,7 @@ void Foam::autoHexMeshDriver::addLayers
     handleWarpedFaces
     (
         pp,
-        maxFaceThicknessRatio,
+        layerParams.maxFaceThicknessRatio(),
         edge0Len,
         cellLevel,
 
@@ -2517,7 +2527,7 @@ void Foam::autoHexMeshDriver::addLayers
 
 
     // Grow out region of non-extrusion
-    for (label i = 0; i < nGrow; i++)
+    for (label i = 0; i < layerParams.nGrow(); i++)
     {
         growNoExtrusion
         (
@@ -2528,21 +2538,24 @@ void Foam::autoHexMeshDriver::addLayers
         );
     }
 
-    // Determine point-wise layer thickness
+    // Determine (wanted) point-wise layer thickness and expansion ratio
     scalarField thickness(pp.nPoints());
     scalarField minThickness(pp.nPoints());
+    scalarField expansionRatio(pp.nPoints());
     calculateLayerThickness
     (
-        expansionRatio,
-        finalLayerRatio,
-        relMinThickness,
         pp,
+        meshMover.adaptPatchIDs(),
+        layerParams.expansionRatio(),
+        layerParams.finalLayerRatio(),
+        layerParams.minThickness(),
         cellLevel,
         patchNLayers,
         edge0Len,
 
         thickness,
-        minThickness
+        minThickness,
+        expansionRatio
     );
 
     // Calculate wall to medial axis distance for smoothing displacement
@@ -2602,9 +2615,9 @@ void Foam::autoHexMeshDriver::addLayers
     medialAxisSmoothingInfo
     (
         meshMover,
-        nSmoothNormals,
-        nSmoothSurfaceNormals,
-        minMedianAxisAngleCos,
+        layerParams.nSmoothNormals(),
+        layerParams.nSmoothSurfaceNormals(),
+        layerParams.minMedianAxisAngleCos(),
 
         dispVec,
         medialRatio,
@@ -2657,8 +2670,8 @@ void Foam::autoHexMeshDriver::addLayers
             //    debug,
             //    meshMover,
             //    -patchDisp,     // Shrink in opposite direction of addedPoints
-            //    nSmoothDisp,
-            //    nSnap
+            //    layerParams.nSmoothDisp(),
+            //    layerParams.nSnap()
             //);
 
             // Medial axis based shrinking
@@ -2666,11 +2679,11 @@ void Foam::autoHexMeshDriver::addLayers
             (
                 meshMover,
 
-                nSmoothThickness,
-                maxThicknessToMedialRatio,
+                layerParams.nSmoothThickness(),
+                layerParams.maxThicknessToMedialRatio(),
                 nAllowableErrors,
-                nSnap,
-                minCosLayerTermination,
+                layerParams.nSnap(),
+                layerParams.layerTerminationCos(),
 
                 thickness,
                 minThickness,
@@ -2735,7 +2748,7 @@ void Foam::autoHexMeshDriver::addLayers
             meshMover,
             patchNLayers,
             extrudeStatus,
-            nBufferCellsNoExtrude,
+            layerParams.nBufferCellsNoExtrude(),
             nPatchPointLayers,
             nPatchFaceLayers
         );
@@ -2747,7 +2760,7 @@ void Foam::autoHexMeshDriver::addLayers
         {
             if (patchNLayers[i] > 0)
             {
-                if (expansionRatio == 1.0)
+                if (expansionRatio[i] == 1.0)
                 {
                     firstDisp[i] = patchDisp[i]/nPatchPointLayers[i];
                 }
@@ -2755,15 +2768,15 @@ void Foam::autoHexMeshDriver::addLayers
                 {
                     label nLay = nPatchPointLayers[i];
                     scalar h =
-                        pow(expansionRatio,nLay - 1)
-                      * (mag(patchDisp[i])*(1.0 - expansionRatio))
-                      / (1.0 - pow(expansionRatio, nLay));
+                        pow(expansionRatio[i], nLay - 1)
+                      * (mag(patchDisp[i])*(1.0 - expansionRatio[i]))
+                      / (1.0 - pow(expansionRatio[i], nLay));
                     firstDisp[i] = h/mag(patchDisp[i])*patchDisp[i];
                 }
             }
         }
 
-        scalar invExpansionRatio = 1.0 / expansionRatio;
+        scalarField invExpansionRatio = 1.0 / expansionRatio;
 
         // Add topo regardless of whether extrudeStatus is extruderemove.
         // Not add layer if patchDisp is zero.
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
index d4c72ea4da..8e074cd05e 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
@@ -37,6 +37,7 @@ Description
 #include "pointEdgePoint.H"
 #include "PointEdgeWave.H"
 #include "mergePoints.H"
+#include "snapParameters.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -95,8 +96,7 @@ Foam::Map<Foam::label> Foam::autoHexMeshDriver::getZoneBafflePatches
             label patchI = globalToPatch_[surfaces().globalRegion(surfI, 0)];
 
             Info<< "For surface "
-                << surfaces()[surfI].IOobject::name()
-                //<< surfaces().names()[surfI]
+                << surfaces().names()[surfI]
                 << " found faceZone " << fZone.name()
                 << " and patch " << mesh_.boundaryMesh()[patchI].name()
                 << endl;
@@ -712,8 +712,8 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::createZoneBaffles
             if (debug_)
             {
                 const_cast<Time&>(mesh_.time())++;
-                Pout<< "Writing baffled mesh to time " << mesh_.time().timeName()
-                    << endl;
+                Pout<< "Writing baffled mesh to time "
+                    << mesh_.time().timeName() << endl;
                 mesh_.write();
             }
         }
@@ -755,14 +755,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::autoHexMeshDriver::mergeZoneBaffles
 
 Foam::scalarField Foam::autoHexMeshDriver::calcSnapDistance
 (
-    const dictionary& snapDict,
+    const snapParameters& snapParams,
     const indirectPrimitivePatch& pp
 ) const
 {
-    // When to snap
-    scalar snapTol(readScalar(snapDict.lookup("snapTol")));
-
-
     const edgeList& edges = pp.edges();
     const labelListList& pointEdges = pp.pointEdges();
     const pointField& localPoints = pp.localPoints();
@@ -793,7 +789,7 @@ Foam::scalarField Foam::autoHexMeshDriver::calcSnapDistance
         false               // no separation
     );
 
-    return snapTol*maxEdgeLen;
+    return snapParams.snapTol()*maxEdgeLen;
 }
 
 
@@ -801,7 +797,7 @@ Foam::scalarField Foam::autoHexMeshDriver::calcSnapDistance
 Foam::labelList Foam::autoHexMeshDriver::getSurfacePatches() const
 {
     // Set of patches originating from surface
-    labelHashSet surfacePatchSet(surfaces().size());
+    labelHashSet surfacePatchSet(globalToPatch_.size());
 
     forAll(globalToPatch_, i)
     {
@@ -826,21 +822,21 @@ Foam::labelList Foam::autoHexMeshDriver::getSurfacePatches() const
 
 void Foam::autoHexMeshDriver::preSmoothPatch
 (
-    const dictionary& snapDict,
+    const snapParameters& snapParams,
     const label nInitErrors,
     const List<labelPair>& baffles,
     motionSmoother& meshMover
 ) const
 {
-    // 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++)
+    for
+    (
+        label smoothIter = 0;
+        smoothIter < snapParams.nSmoothPatch();
+        smoothIter++
+    )
     {
         Info<< "Smoothing iteration " << smoothIter << endl;
         checkFaces.setSize(mesh_.nFaces());
@@ -857,11 +853,11 @@ void Foam::autoHexMeshDriver::preSmoothPatch
 
         scalar oldErrorReduction = -1;
 
-        for (label snapIter = 0; snapIter < 2*nSnap; snapIter++)
+        for (label snapIter = 0; snapIter < 2*snapParams.nSnap(); snapIter++)
         {
             Info<< nl << "Scaling iteration " << snapIter << endl;
 
-            if (snapIter == nSnap)
+            if (snapIter == snapParams.nSnap())
             {
                 Info<< "Displacement scaling for error reduction set to 0."
                     << endl;
@@ -901,6 +897,56 @@ void Foam::autoHexMeshDriver::preSmoothPatch
 }
 
 
+// Get (pp-local) indices of points that are both on zone and on patched surface
+Foam::labelList Foam::autoHexMeshDriver::getZoneSurfacePoints
+(
+    const indirectPrimitivePatch& pp,
+    const word& zoneName
+) const
+{
+    label zoneI = mesh_.faceZones().findZoneID(zoneName);
+
+    if (zoneI == -1)
+    {
+        FatalErrorIn
+        (
+            "autoHexMeshDriver::getZoneSurfacePoints"
+            "(const indirectPrimitivePatch&, const word&)"
+        )   << "Cannot find zone " << zoneName
+            << exit(FatalError);
+    }
+
+    const faceZone& fZone = mesh_.faceZones()[zoneI];
+
+
+    // Could use PrimitivePatch & localFaces to extract points but might just
+    // as well do it ourselves.
+
+    boolList pointOnZone(pp.nPoints(), false);
+
+    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();
+                pointOnZone[pointI] = true;
+            }
+        }
+    }
+
+    return findIndices(pointOnZone, true);
+}
+
+
 Foam::vectorField Foam::autoHexMeshDriver::calcNearestSurface
 (
     const scalarField& snapDist,
@@ -925,33 +971,40 @@ Foam::vectorField Foam::autoHexMeshDriver::calcNearestSurface
     // 1. All points to non-interface surfaces
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    forAll(localPoints, pointI)
     {
-        pointIndexHit pHit;
-
-        label surfI = surfaces().findNearest
+        List<pointIndexHit> hitInfo;
+        labelList hitSurface;
+        surfaces().findNearest
         (
             unzonedSurfaces,
-            localPoints[pointI],
-            sqr(4*snapDist[pointI]),            // sqr of attract distance
-            pHit
+            localPoints,
+            sqr(4*snapDist),        // sqr of attract distance
+            hitSurface,
+            hitInfo
         );
 
-        if (surfI != -1)
+        forAll(hitInfo, pointI)
         {
-            patchDisp[pointI] = pHit.hitPoint() - localPoints[pointI];
+            if (hitInfo[pointI].hit())
+            {
+                patchDisp[pointI] =
+                    hitInfo[pointI].hitPoint()
+                  - localPoints[pointI];
+            }
+            //else
+            //{
+            //   WarningIn("autoHexMeshDriver::calcNearestSurface(..)")
+            //        << "For point:" << pointI
+            //        << " coordinate:" << localPoints[pointI]
+            //        << " did not find any surface within:"
+            //        << 4*snapDist[pointI]
+            //        << " meter." << endl;
+            //}
         }
-        //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
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -964,50 +1017,50 @@ Foam::vectorField Foam::autoHexMeshDriver::calcNearestSurface
 
         const labelList surfacesToTest(1, zoneSurfI);
 
-        label zoneI = mesh_.faceZones().findZoneID(faceZoneNames[zoneSurfI]);
+        // Get indices of points both on faceZone and on pp.
+        labelList zonePointIndices
+        (
+            getZoneSurfacePoints
+            (
+                pp,
+                faceZoneNames[zoneSurfI]
+            )
+        );
 
-        const faceZone& fZone = mesh_.faceZones()[zoneI];
-
-        forAll(fZone, i)
+        pointField zonePoints(zonePointIndices.size());
+        forAll(zonePointIndices, i)
         {
-            const face& f = mesh_.faces()[fZone[i]];
+            zonePoints[i] = localPoints[zonePointIndices[i]];
+        }
 
-            forAll(f, fp)
+        // Find nearest for points both on faceZone and pp.
+        List<pointIndexHit> hitInfo;
+        labelList hitSurface;
+        surfaces().findNearest
+        (
+            labelList(1, zoneSurfI),
+            zonePoints,
+            sqr(4*snapDist),
+            hitSurface,
+            hitInfo
+        );
+
+        forAll(hitInfo, pointI)
+        {
+            if (hitInfo[pointI].hit())
             {
-                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;
-                    }
-                }
+                patchDisp[pointI] =
+                    hitInfo[pointI].hitPoint()
+                  - localPoints[pointI];
+            }
+            else
+            {
+                WarningIn("autoHexMeshDriver::calcNearestSurface(..)")
+                    << "For point:" << pointI
+                    << " coordinate:" << localPoints[pointI]
+                    << " did not find any surface within:"
+                    << 4*snapDist[pointI]
+                    << " meter." << endl;
             }
         }
     }
@@ -1078,7 +1131,7 @@ Foam::vectorField Foam::autoHexMeshDriver::calcNearestSurface
 
 void Foam::autoHexMeshDriver::smoothDisplacement
 (
-    const dictionary& snapDict,
+    const snapParameters& snapParams,
     motionSmoother& meshMover
 ) const
 {
@@ -1087,9 +1140,6 @@ void Foam::autoHexMeshDriver::smoothDisplacement
 
     Info<< "Smoothing displacement ..." << endl;
 
-    // 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);
@@ -1098,7 +1148,7 @@ void Foam::autoHexMeshDriver::smoothDisplacement
     // Get displacement field
     pointVectorField& disp = meshMover.displacement();
 
-    for (label iter = 0; iter < nSmoothDisp; iter++)
+    for (label iter = 0; iter < snapParams.nSmoothDispl(); iter++)
     {
         if ((iter % 10) == 0)
         {
@@ -1140,16 +1190,12 @@ void Foam::autoHexMeshDriver::smoothDisplacement
 
 void Foam::autoHexMeshDriver::scaleMesh
 (
-    const dictionary& snapDict,
+    const snapParameters& snapParams,
     const label nInitErrors,
     const List<labelPair>& baffles,
     motionSmoother& meshMover
 )
 {
-    // Snapping iterations
-    label nSnap(readLabel(snapDict.lookup("nSnap")));
-
-
     // Relax displacement until correct mesh
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     labelList checkFaces(identity(mesh_.nFaces()));
@@ -1157,11 +1203,11 @@ void Foam::autoHexMeshDriver::scaleMesh
     scalar oldErrorReduction = -1;
 
     Info<< "Moving mesh ..." << endl;
-    for (label iter = 0; iter < 2*nSnap; iter++)
+    for (label iter = 0; iter < 2*snapParams.nSnap(); iter++)
     {
         Info<< nl << "Iteration " << iter << endl;
 
-        if (iter == nSnap)
+        if (iter == snapParams.nSnap())
         {
             Info<< "Displacement scaling for error reduction set to 0." << endl;
             oldErrorReduction = meshMover.setErrorReduction(0.0);
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
new file mode 100644
index 0000000000..1d3a18714a
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
@@ -0,0 +1,213 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "layerParameters.H"
+#include "polyBoundaryMesh.H"
+#include "mathematicalConstants.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const Foam::scalar Foam::layerParameters::defaultConcaveAngle = 90;
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from dictionary
+Foam::layerParameters::layerParameters
+(
+    const dictionary& dict,
+    const labelList& numLayers
+)
+:
+    numLayers_(numLayers),
+    expansionRatio_
+    (
+        numLayers_.size(),
+        readScalar(dict.lookup("expansionRatio"))
+    ),
+    finalLayerRatio_
+    (
+        numLayers_.size(),
+        readScalar(dict.lookup("finalLayerRatio"))
+    ),
+    minThickness_
+    (
+        numLayers_.size(),
+        readScalar(dict.lookup("minThickness"))
+    ),
+    featureAngle_(readScalar(dict.lookup("featureAngle"))),
+    concaveAngle_
+    (
+        dict.found("concaveAngle")
+      ? readScalar(dict.lookup("concaveAngle"))
+      : defaultConcaveAngle
+    ),
+    nGrow_(readLabel(dict.lookup("nGrow"))),
+    nSmoothSurfaceNormals_
+    (
+        readLabel(dict.lookup("nSmoothSurfaceNormals"))
+    ),
+    nSmoothNormals_(readLabel(dict.lookup("nSmoothNormals"))),
+    nSmoothThickness_(readLabel(dict.lookup("nSmoothThickness"))),
+    maxFaceThicknessRatio_
+    (
+        readScalar(dict.lookup("maxFaceThicknessRatio"))
+    ),
+    layerTerminationCos_
+    (
+        Foam::cos
+        (
+            0.5
+          * featureAngle_
+          * mathematicalConstant::pi/180.
+        )
+    ),
+    maxThicknessToMedialRatio_
+    (
+        readScalar(dict.lookup("maxThicknessToMedialRatio"))
+    ),
+    minMedianAxisAngleCos_
+    (
+        Foam::cos(readScalar(dict.lookup("minMedianAxisAngle")))
+      * mathematicalConstant::pi/180.
+    ),
+    nBufferCellsNoExtrude_
+    (
+        readLabel(dict.lookup("nBufferCellsNoExtrude"))
+    ),
+    nSnap_(readLabel(dict.lookup("nSnap")))
+{}
+
+
+// Construct from dictionary
+Foam::layerParameters::layerParameters
+(
+    const dictionary& dict,
+    const polyBoundaryMesh& boundaryMesh
+)
+:
+    numLayers_(boundaryMesh.size(), 0),
+    expansionRatio_
+    (
+        boundaryMesh.size(),
+        readScalar(dict.lookup("expansionRatio"))
+    ),
+    finalLayerRatio_
+    (
+        boundaryMesh.size(),
+        readScalar(dict.lookup("finalLayerRatio"))
+    ),
+    minThickness_
+    (
+        boundaryMesh.size(),
+        readScalar(dict.lookup("minThickness"))
+    ),
+    featureAngle_(readScalar(dict.lookup("featureAngle"))),
+    concaveAngle_
+    (
+        dict.found("concaveAngle")
+      ? readScalar(dict.lookup("concaveAngle"))
+      : defaultConcaveAngle
+    ),
+    nGrow_(readLabel(dict.lookup("nGrow"))),
+    nSmoothSurfaceNormals_
+    (
+        readLabel(dict.lookup("nSmoothSurfaceNormals"))
+    ),
+    nSmoothNormals_(readLabel(dict.lookup("nSmoothNormals"))),
+    nSmoothThickness_(readLabel(dict.lookup("nSmoothThickness"))),
+    maxFaceThicknessRatio_
+    (
+        readScalar(dict.lookup("maxFaceThicknessRatio"))
+    ),
+    layerTerminationCos_
+    (
+        Foam::cos
+        (
+            0.5
+          * featureAngle_
+          * mathematicalConstant::pi/180.
+        )
+    ),
+    maxThicknessToMedialRatio_
+    (
+        readScalar(dict.lookup("maxThicknessToMedialRatio"))
+    ),
+    minMedianAxisAngleCos_
+    (
+        Foam::cos(readScalar(dict.lookup("minMedianAxisAngle")))
+      * mathematicalConstant::pi/180.
+    ),
+    nBufferCellsNoExtrude_
+    (
+        readLabel(dict.lookup("nBufferCellsNoExtrude"))
+    ),
+    nSnap_(readLabel(dict.lookup("nRelaxIter")))
+{
+    const dictionary& layersDict = dict.subDict("layers");
+
+    forAllConstIter(dictionary, layersDict, iter)
+    {
+        const word& key = iter().keyword();
+
+        if (layersDict.isDict(key))
+        {
+            label patchI = boundaryMesh.findPatchID(key);
+
+            if (patchI == -1)
+            {
+                FatalErrorIn
+                (
+                    "layerParameters::layerParameters"
+                    "(const dictionary&, const polyBoundaryMesh&)"
+                )   << "Specified illegal patch " << key
+                    << " in layer dictionary." << endl
+                    << "Valid patch names are " << boundaryMesh.names()
+                    << exit(FatalError);
+            }
+
+            const dictionary& layerDict = layersDict.subDict(key);
+
+            numLayers_[patchI] =
+                readLabel(layerDict.lookup("nSurfaceLayers"));
+
+            //- Patch-wise layer parameters disabled for now. Just remove
+            //  settings in initialiser list and uncomment below.
+            //expansionRatio_[patchI] =
+            //    readScalar(layerDict.lookup("expansionRatio"));
+            //finalLayerRatio_[patchI] =
+            //    readScalar(layerDict.lookup("finalLayerRatio"));
+            //minThickness_[patchI] =
+            //    readScalar(layerDict.lookup("minThickness"));
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
new file mode 100644
index 0000000000..9c16e27116
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
@@ -0,0 +1,246 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::layerParameters
+
+Description
+    Simple container to keep together layer specific information.
+
+SourceFiles
+    layerParameters.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef layerParameters_H
+#define layerParameters_H
+
+#include "dictionary.H"
+#include "scalarField.H"
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class polyBoundaryMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class layerParameters Declaration
+\*---------------------------------------------------------------------------*/
+
+class layerParameters
+{
+    // Static data members
+
+        //- Default angle for faces to be convcave
+        static const scalar defaultConcaveAngle;
+
+
+    // Private data
+
+        // Per patch (not region!) information
+
+            //- How many layers to add.
+            labelList numLayers_;
+
+            scalarField expansionRatio_;
+
+            //- Wanted thickness of final added cell layer. If multiple layers
+            //  is the thickness of the layer furthest away from the wall.
+            //  Relative to undistorted size of cell outside layer.
+            scalarField finalLayerRatio_;
+
+            //- Minimum thickness of cell layer. If for any reason layer
+            //  cannot be above minThickness do not add layer.
+            //  Relative to undistorted size of cell outside layer.
+            scalarField minThickness_;
+
+
+        scalar featureAngle_;
+
+        scalar concaveAngle_;
+
+        label nGrow_;
+
+        label nSmoothSurfaceNormals_;
+
+        label nSmoothNormals_;
+
+        label nSmoothThickness_;
+
+        scalar maxFaceThicknessRatio_;
+
+        scalar layerTerminationCos_;
+
+        scalar maxThicknessToMedialRatio_;
+
+        scalar minMedianAxisAngleCos_;
+
+        label nBufferCellsNoExtrude_;
+
+        label nSnap_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        layerParameters(const layerParameters&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const layerParameters&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary - old syntax
+        layerParameters(const dictionary& dict, const labelList& numLayers);
+
+        //- Construct from dictionary - new syntax
+        layerParameters(const dictionary& dict, const polyBoundaryMesh&);
+
+
+    // Member Functions
+
+        // Access
+
+            // Per patch information
+
+                //- How many layers to add.
+                const labelList& numLayers() const
+                {
+                    return numLayers_;
+                }
+
+                // Expansion factor for layer mesh
+                const scalarField& expansionRatio() const
+                {
+                    return expansionRatio_;
+                }
+
+                //- Wanted thickness of final added cell layer. If multiple
+                //  layers
+                //  is the thickness of the layer furthest away from the wall.
+                //  Relative to undistorted size of cell outside layer.
+                const scalarField& finalLayerRatio() const
+                {
+                    return finalLayerRatio_;
+                }
+
+                //- Minimum thickness of cell layer. If for any reason layer
+                //  cannot be above minThickness do not add layer.
+                //  Relative to undistorted size of cell outside layer.
+                const scalarField& minThickness() const
+                {
+                    return minThickness_;
+                }
+
+
+            scalar featureAngle() const
+            {
+                return featureAngle_;
+            }
+
+            scalar concaveAngle() const
+            {
+                return concaveAngle_;
+            }
+
+            //- If points get not extruded do nGrow layers of connected faces
+            //  that are not grown. Is used to not do layers at all close to
+            //  features.
+            label nGrow() const
+            {
+                return nGrow_;
+            }
+
+            // Number of smoothing iterations of surface normals 
+            label nSmoothSurfaceNormals() const
+            {
+                return nSmoothSurfaceNormals_;
+            }
+
+            // Number of smoothing iterations of interior mesh movement
+            // direction  
+            label nSmoothNormals() const
+            {
+                return nSmoothNormals_;
+            }
+
+            // Smooth layer thickness over surface patches
+            label nSmoothThickness() const
+            {
+                return nSmoothThickness_;
+            }
+
+            // Stop layer growth on highly warped cells 
+            scalar maxFaceThicknessRatio() const
+            {
+                return maxFaceThicknessRatio_;
+            }
+
+            scalar layerTerminationCos() const
+            {
+                return layerTerminationCos_;
+            }
+
+            // Reduce layer growth where ratio thickness to medial 
+            // distance is large 
+            scalar maxThicknessToMedialRatio() const
+            {
+                return maxThicknessToMedialRatio_;
+            }
+
+            // Angle used to pick up medial axis points
+            scalar minMedianAxisAngleCos() const
+            {
+                return minMedianAxisAngleCos_;
+            }
+
+            // Create buffer region for new layer terminations
+            label nBufferCellsNoExtrude() const
+            {
+                return nBufferCellsNoExtrude_;
+            }
+
+            label nSnap() const
+            {
+                return nSnap_;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
new file mode 100644
index 0000000000..7912279e01
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
@@ -0,0 +1,123 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "refinementParameters.H"
+#include "mathematicalConstants.H"
+#include "polyMesh.H"
+#include "globalIndex.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from dictionary
+Foam::refinementParameters::refinementParameters
+(
+    const dictionary& dict,
+    const label dummy
+)
+:
+    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"))
+{}
+
+
+Foam::refinementParameters::refinementParameters(const dictionary& dict)
+:
+    maxGlobalCells_(readLabel(dict.lookup("maxGlobalCells"))),
+    maxLocalCells_(readLabel(dict.lookup("maxLocalCells"))),
+    minRefineCells_(readLabel(dict.lookup("minRefinementCells"))),
+    nBufferLayers_(readLabel(dict.lookup("nCellsBetweenLevels"))),
+    keepPoints_(pointField(1, dict.lookup("locationInMesh")))
+{
+    scalar featAngle(readScalar(dict.lookup("resolveFeatureAngle")));
+
+    if (featAngle < 0 || featAngle > 180)
+    {
+        curvature_ = -GREAT;
+    }
+    else
+    {
+        curvature_ = Foam::cos(featAngle*mathematicalConstant::pi/180.0);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::labelList Foam::refinementParameters::findCells(const polyMesh& mesh)
+ 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
+            (
+                "refinementParameters::findCells(const polyMesh&) const"
+            )   << "Point " << keepPoint
+                << " is not inside the mesh or on a face or edge." << nl
+                << "Bounding box of the mesh:" << mesh.bounds()
+                << exit(FatalError);
+        }
+
+        if (globalCells.isLocal(globalCellI))
+        {
+            cellLabels[i] = localCellI;
+        }
+        else
+        {
+            cellLabels[i] = -1;
+        }
+    }
+    return cellLabels;
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
new file mode 100644
index 0000000000..25b97af034
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::refinementParameters
+
+Description
+    Simple container to keep together refinement specific information.
+
+SourceFiles
+    refinementParameters.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef refinementParameters_H
+#define refinementParameters_H
+
+#include "dictionary.H"
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class refinementParameters Declaration
+\*---------------------------------------------------------------------------*/
+
+class refinementParameters
+{
+    // Private data
+
+        //- Total number of cells
+        const label maxGlobalCells_;
+
+        //- Per processor max number of cells
+        const label maxLocalCells_;
+
+        //- When to stop refining
+        const label minRefineCells_;
+
+        //- Curvature
+        scalar curvature_;
+
+        //- Number of layers between different refinement levels
+        const label nBufferLayers_;
+
+        //- Areas to keep
+        const pointField keepPoints_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        refinementParameters(const refinementParameters&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const refinementParameters&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary - old syntax
+        refinementParameters(const dictionary& dict, const label dummy);
+
+        //- Construct from dictionary - new syntax
+        refinementParameters(const dictionary& dict);
+
+
+    // Member Functions
+
+        // Access
+
+            //- Total number of cells
+            label maxGlobalCells() const
+            {
+                return maxGlobalCells_;
+            }
+
+            //- Per processor max number of cells
+            label maxLocalCells() const
+            {
+                return maxLocalCells_;
+            }
+
+            //- When to stop refining
+            label minRefineCells() const
+            {
+                return minRefineCells_;
+            }
+
+            //- Curvature
+            scalar curvature() const
+            {
+                return curvature_;
+            }
+
+            //- Number of layers between different refinement levels
+            label nBufferLayers() const
+            {
+                return nBufferLayers_;
+            }
+
+            //- Areas to keep
+            const pointField& keepPoints() const
+            {
+                return keepPoints_;
+            }
+
+
+        // Other
+
+            //- Checks that cells are in mesh. Returns cells they are in.
+            labelList findCells(const polyMesh&) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
new file mode 100644
index 0000000000..253826c38f
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "snapParameters.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from dictionary
+Foam::snapParameters::snapParameters(const dictionary& dict, const label dummy)
+:
+    nSmoothPatch_(readLabel(dict.lookup("nSmoothPatch"))),
+    snapTol_(readScalar(dict.lookup("snapTol"))),
+    nSmoothDispl_(readLabel(dict.lookup("nSmoothDispl"))),
+    nSnap_(readLabel(dict.lookup("nSnap")))
+{}
+
+
+// Construct from dictionary
+Foam::snapParameters::snapParameters(const dictionary& dict)
+:
+    nSmoothPatch_(readLabel(dict.lookup("nSmoothPatch"))),
+    snapTol_(readScalar(dict.lookup("tolerance"))),
+    nSmoothDispl_(readLabel(dict.lookup("nSolveIter"))),
+    nSnap_(readLabel(dict.lookup("nRelaxIter")))
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
new file mode 100644
index 0000000000..2a173578b0
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::snapParameters
+
+Description
+    Simple container to keep together snap specific information.
+
+SourceFiles
+    snapParameters.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef snapParameters_H
+#define snapParameters_H
+
+#include "dictionary.H"
+#include "scalar.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+
+/*---------------------------------------------------------------------------*\
+                           Class snapParameters Declaration
+\*---------------------------------------------------------------------------*/
+
+class snapParameters
+{
+    // Private data
+
+        const label nSmoothPatch_;
+
+        const scalar snapTol_;
+
+        const label nSmoothDispl_;
+
+        const label nSnap_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        snapParameters(const snapParameters&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const snapParameters&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary - old syntax
+        snapParameters(const dictionary& dict, const label dummy);
+
+        //- Construct from dictionary - new syntax
+        snapParameters(const dictionary& dict);
+
+
+    // Member Functions
+
+        // Access
+
+            //- Number of patch smoothing iterations before finding
+            //  correspondence to surface
+            label nSmoothPatch() const
+            {
+                return nSmoothPatch_;
+            }
+
+            //- Relative distance for points to be attracted by surface
+            //  feature point
+            //  or edge. True distance is this factor times local
+            //  maximum edge length.
+            scalar snapTol() const
+            {
+                return snapTol_;
+            }
+
+            //- Number of mesh displacement smoothing iterations.
+            label nSmoothDispl() const
+            {
+                return nSmoothDispl_;
+            }
+
+            //- Maximum number of snapping relaxation iterations. Should stop
+            //  before upon reaching a correct mesh.
+            label nSnap() const
+            {
+                return nSnap_;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
index 8b9869ad57..a60e7758da 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -24,9 +24,7 @@ License
 
 \*----------------------------------------------------------------------------*/
 
-#include "Pstream.H"
 #include "meshRefinement.H"
-
 #include "volMesh.H"
 #include "volFields.H"
 #include "surfaceMesh.H"
@@ -34,7 +32,6 @@ License
 #include "Time.H"
 #include "refinementHistory.H"
 #include "refinementSurfaces.H"
-#include "cellSet.H"
 #include "decompositionMethod.H"
 #include "regionSplit.H"
 #include "fvMeshDistribute.H"
@@ -50,8 +47,9 @@ License
 #include "globalPointPatchFields.H"
 #include "calculatedPointPatchFields.H"
 #include "processorPointPatch.H"
-#include "featureEdgeMesh.H"
 #include "globalIndex.H"
+#include "meshTools.H"
+#include "OFstream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -117,90 +115,6 @@ void Foam::meshRefinement::calcNeighbourData
 }
 
 
-//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)
@@ -220,33 +134,46 @@ void Foam::meshRefinement::updateIntersections(const labelList& changedFaces)
     pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
     calcNeighbourData(neiLevel, neiCc);
 
+    // Collect segments we want to test for
+    pointField start(changedFaces.size());
+    pointField end(changedFaces.size());
+
     forAll(changedFaces, i)
     {
         label faceI = changedFaces[i];
         label own = mesh_.faceOwner()[faceI];
 
-        pointIndexHit surfaceHitInfo;
-
+        start[i] = cellCentres[own];
         if (mesh_.isInternalFace(faceI))
         {
-            surfaceIndex_[faceI] = surfaces_.findAnyIntersection
-            (
-                cellCentres[own],
-                cellCentres[mesh_.faceNeighbour()[faceI]],
-                surfaceHitInfo
-            );
+            end[i] = cellCentres[mesh_.faceNeighbour()[faceI]];
         }
         else
         {
-            surfaceIndex_[faceI] = surfaces_.findAnyIntersection
-            (
-                cellCentres[own],
-                neiCc[faceI-mesh_.nInternalFaces()],
-                surfaceHitInfo
-            );
+            end[i] = neiCc[faceI-mesh_.nInternalFaces()];
         }
     }
 
+    // Do tests in one go
+    labelList surfaceHit;
+    {
+        labelList surfaceLevel;
+        surfaces_.findHigherIntersection
+        (
+            start,
+            end,
+            labelList(start.size(), -1),    // accept any intersection
+            surfaceHit,
+            surfaceLevel
+        );
+    }
+
+    // Keep just surface hit
+    forAll(surfaceHit, i)
+    {
+        surfaceIndex_[changedFaces[i]] = surfaceHit[i];
+    }
+
     // 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);
@@ -305,67 +232,72 @@ void Foam::meshRefinement::checkData()
     }
     // 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++
-        )
+        // Collect segments we want to test for
+        pointField start(mesh_.nFaces());
+        pointField end(mesh_.nFaces());
+
+        forAll(start, faceI)
         {
-            label own = mesh_.faceOwner()[faceI];
-            const point& ownCc = mesh_.cellCentres()[own];
+            start[faceI] = mesh_.cellCentres()[mesh_.faceOwner()[faceI]];
 
-            pointIndexHit surfaceHitInfo;
-            label surfI = surfaces_.findAnyIntersection
-            (
-                ownCc,
-                neiCc[faceI-mesh_.nInternalFaces()],
-                surfaceHitInfo
-            );
-
-            if (surfI != surfaceIndex_[faceI])
+            if (mesh_.isInternalFace(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;
+                end[faceI] = mesh_.cellCentres()[mesh_.faceNeighbour()[faceI]];
+            }
+            else
+            {
+                end[faceI] = neiCc[faceI-mesh_.nInternalFaces()];
+            }
+        }
+
+        // Do tests in one go
+        labelList surfaceHit;
+        {
+            labelList surfaceLevel;
+            surfaces_.findHigherIntersection
+            (
+                start,
+                end,
+                labelList(start.size(), -1),    // accept any intersection
+                surfaceHit,
+                surfaceLevel
+            );
+        }
+
+        // Check
+        forAll(surfaceHit, faceI)
+        {
+            if (surfaceHit[faceI] != surfaceIndex_[faceI])
+            {
+                if (mesh_.isInternalFace(faceI))
+                {
+                    WarningIn("meshRefinement::checkData()")
+                        << "Internal face:" << faceI
+                        << " fc:" << mesh_.faceCentres()[faceI]
+                        << " cached surfaceIndex_:" << surfaceIndex_[faceI]
+                        << " current:" << surfaceHit[faceI]
+                        << " ownCc:"
+                        << mesh_.cellCentres()[mesh_.faceOwner()[faceI]]
+                        << " neiCc:"
+                        << mesh_.cellCentres()[mesh_.faceNeighbour()[faceI]]
+                        << endl;
+                }
+                else
+                {
+                    WarningIn("meshRefinement::checkData()")
+                        << "Boundary face:" << faceI
+                        << " fc:" << mesh_.faceCentres()[faceI]
+                        << " cached surfaceIndex_:" << surfaceIndex_[faceI]
+                        << " current:" << surfaceHit[faceI]
+                        << " ownCc:"
+                        << mesh_.cellCentres()[mesh_.faceOwner()[faceI]]
+                        << endl;
+                }
             }
         }
     }
@@ -492,283 +424,6 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRemoveCells
 }
 
 
-// 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
@@ -835,12 +490,14 @@ Foam::meshRefinement::meshRefinement
 (
     fvMesh& mesh,
     const scalar tol,
-    const refinementSurfaces& surfaces
+    const refinementSurfaces& surfaces,
+    const shellSurfaces& shells
 )
 :
     mesh_(mesh),
     tol_(tol),
     surfaces_(surfaces),
+    shells_(shells),
     meshCutter_
     (
         mesh,
@@ -926,109 +583,6 @@ Foam::label Foam::meshRefinement::countHits() const
 }
 
 
-//// 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
 (
@@ -1213,9 +767,8 @@ Foam::labelList Foam::meshRefinement::intersectedPoints
 
             forAll(f, fp)
             {
-                if (isBoundaryPoint.get(f[fp]) == 0u)
+                if (isBoundaryPoint.set(f[fp], 1u))
                 {
-                    isBoundaryPoint.set(f[fp], 1u);
                     nBoundaryPoints++;
                 }
             }
@@ -1239,9 +792,7 @@ Foam::labelList Foam::meshRefinement::intersectedPoints
     //
     //            forAll(f, fp)
     //            {
-    //                if (isBoundaryPoint.get(f[fp]) == 0u)
-    //                {
-    //                    isBoundaryPoint.set(f[fp], 1u);
+    //                if (isBoundaryPoint.set(f[fp], 1u))
     //                    nBoundaryPoints++;
     //                }
     //            }
@@ -1910,53 +1461,56 @@ void Foam::meshRefinement::dumpIntersections(const fileName& prefix) const
             << " 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
+        // Redo all intersections
+        // ~~~~~~~~~~~~~~~~~~~~~~
 
         // 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)
+        labelList intersectionFaces(intersectedFaces());
+
+        // Collect segments we want to test for
+        pointField start(intersectionFaces.size());
+        pointField end(intersectionFaces.size());
+
+        forAll(intersectionFaces, i)
         {
-            label faceI = i + mesh_.nInternalFaces();
+            label faceI = intersectionFaces[i];
+            start[i] = cellCentres[mesh_.faceOwner()[faceI]];
 
-            if (surfaceIndex_[faceI] != -1)
+            if (mesh_.isInternalFace(faceI))
             {
-                const point& ownCc = cellCentres[mesh_.faceOwner()[faceI]];
+                end[i] = cellCentres[mesh_.faceNeighbour()[faceI]];
+            }
+            else
+            {
+                end[i] = neiCc[faceI-mesh_.nInternalFaces()];
+            }
+        }
 
-                // Re-intersect to get position
-                pointIndexHit surfaceHitInfo;
-                surfaces_.findAnyIntersection(ownCc, neiCc[i], surfaceHitInfo);
+        // Do tests in one go
+        labelList surfaceHit;
+        List<pointIndexHit> surfaceHitInfo;
+        surfaces_.findAnyIntersection
+        (
+            start,
+            end,
+            surfaceHit,
+            surfaceHitInfo
+        );
 
-                meshTools::writeOBJ(str, ownCc);
+        forAll(intersectionFaces, i)
+        {
+            if (surfaceHit[i] != -1)
+            {
+                meshTools::writeOBJ(str, start[i]);
                 vertI++;
-                meshTools::writeOBJ(str, surfaceHitInfo.hitPoint());
+                meshTools::writeOBJ(str, surfaceHitInfo[i].hitPoint());
                 vertI++;
-                meshTools::writeOBJ(str, neiCc[i]);
+                meshTools::writeOBJ(str, end[i]);
                 vertI++;
                 str << "l " << vertI-2 << ' ' << vertI-1 << nl
                     << "l " << vertI-1 << ' ' << vertI << nl;
@@ -1996,13 +1550,4 @@ void Foam::meshRefinement::write
 }
 
 
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-
 // ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
index 78fed53493..e8e633bfef 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
@@ -30,7 +30,7 @@ Description
     (static) surfaces.
 
     Maintains
-    - per face any intersections of this edge with any of the surfaces
+    - per face any intersections of the cc-cc segment with any of the surfaces
 
 SourceFiles
     meshRefinement.C
@@ -62,6 +62,7 @@ class fvMesh;
 class mapDistributePolyMesh;
 class decompositionMethod;
 class refinementSurfaces;
+class shellSurfaces;
 class removeCells;
 class featureEdgeMesh;
 class fvMeshDistribute;
@@ -107,8 +108,12 @@ private:
         //- tolerance used for sorting coordinates (used in 'less' routine)
         const scalar tol_;
 
+        //- All surface-intersection interaction
         const refinementSurfaces& surfaces_;
 
+        //- All shell-refinement interaction
+        const shellSurfaces& shells_;
+
         //- refinement engine
         hexRef8 meshCutter_;
 
@@ -229,14 +234,18 @@ private:
             //- 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;
 
+            //- Collect faces that are intersected and whose neighbours aren't
+            //  yet marked  for refinement.
+            labelList getRefineCandidateFaces
+            (
+                const labelList& refineCell
+            ) const;
+
             //- Mark cells for surface intersection based refinement.
             label markSurfaceRefinement
             (
@@ -252,17 +261,13 @@ private:
             //  regions.
             bool checkCurvature
             (
-                const labelList& globalToPatch,
                 const scalar curvature,
-                const bool markDifferingRegions,
                 const label nAllowRefine,
-                const label newSurfI,
-                const label newTriI,
+                const label surfaceLevel,
+                const vector& surfaceNormal,
                 const label cellI,
-
-                label& maxCellSurfI,
-                label& maxCellTriI,
-
+                label& cellMaxLevel,
+                vector& cellMaxNormal,
                 labelList& refineCell,
                 label& nRefine
             ) const;
@@ -273,9 +278,7 @@ private:
             //  (markDifferingRegions)
             label markSurfaceCurvatureRefinement
             (
-                const labelList& globalToPatch,
                 const scalar curvature,
-                const bool markDifferingRegions,
                 const label nAllowRefine,
                 const labelList& neiLevel,
                 const pointField& neiCc,
@@ -381,7 +384,8 @@ public:
         (
             fvMesh& mesh,
             const scalar tol,
-            const refinementSurfaces&
+            const refinementSurfaces&,
+            const shellSurfaces&
         );
 
 
@@ -482,22 +486,18 @@ public:
                 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,
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
index 17eaaeaa27..c9c2d14c13 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -249,7 +249,7 @@ void Foam::meshRefinement::getBafflePatches
             if (debug)
             {
                 Pout<< "getBafflePatches : Not baffling surface "
-                    << surfaces_[surfI].searchableSurface::name() << endl;
+                    << surfaces_.names()[surfI] << endl;
             }
         }
         else
@@ -264,69 +264,95 @@ void Foam::meshRefinement::getBafflePatches
     neiPatch.setSize(mesh_.nFaces());
     neiPatch = -1;
 
-    forAll(surfaceIndex_, faceI)
+
+    // Collect candidate faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList testFaces(intersectedFaces());
+
+    // Collect segments
+    // ~~~~~~~~~~~~~~~~
+
+    pointField start(testFaces.size());
+    pointField end(testFaces.size());
+
+    forAll(testFaces, i)
     {
-        if (surfaceIndex_[faceI] != -1)
+        label faceI = testFaces[i];
+
+        label own = mesh_.faceOwner()[faceI];
+
+        if (mesh_.isInternalFace(faceI))
         {
-            // Edge between owner and neighbour of face pierces a surface.
-            // Do closer inspection to find nearest intersection on both sides.
+            start[i] = cellCentres[own];
+            end[i] = cellCentres[mesh_.faceNeighbour()[faceI]];
+        }
+        else
+        {
+            start[i] = cellCentres[own];
+            end[i] = neiCc[faceI-mesh_.nInternalFaces()];
+        }
+    }
 
-            label own = mesh_.faceOwner()[faceI];
 
-            // Cc of neighbouring cell
-            point end
-            (
-                mesh_.isInternalFace(faceI)
-              ? cellCentres[mesh_.faceNeighbour()[faceI]]
-              : neiCc[faceI-mesh_.nInternalFaces()]
-            );
+    // Do test for intersections
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~
+    labelList surface1;
+    List<pointIndexHit> hit1;
+    labelList region1;
+    labelList surface2;
+    List<pointIndexHit> hit2;
+    labelList region2;
+    surfaces_.findNearestIntersection
+    (
+        surfacesToBaffle,
+        start,
+        end,
 
-            label surface1, surface2;
-            pointIndexHit hit1, hit2;
-            surfaces_.findNearestIntersection
-            (
-                surfacesToBaffle,
-                cellCentres[own],
-                end,
+        surface1,
+        hit1,
+        region1,
 
-                surface1,
-                hit1,
-                surface2,
-                hit2
-            );
+        surface2,
+        hit2,
+        region2
+    );
 
-            if (hit1.hit() && hit2.hit())
+    forAll(testFaces, i)
+    {
+        label faceI = testFaces[i];
+
+        if (hit1[i].hit() && hit2[i].hit())
+        {
+            if (str.valid())
             {
-                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;
-                }
+                meshTools::writeOBJ(str(), start[i]);
+                vertI++;
+                meshTools::writeOBJ(str(), hit1[i].rawPoint());
+                vertI++;
+                meshTools::writeOBJ(str(), hit2[i].rawPoint());
+                vertI++;
+                meshTools::writeOBJ(str(), end[i]);
+                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_.globalRegion(surface1[i], region1[i])
+            ];
+            neiPatch[faceI] = globalToPatch
+            [
+                surfaces_.globalRegion(surface2[i], region2[i])
+            ];
 
-                // 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);
-                }
+            if (ownPatch[faceI] == -1 || neiPatch[faceI] == -1)
+            {
+                FatalErrorIn("getBafflePatches(..)")
+                    << "problem." << abort(FatalError);
             }
         }
     }
@@ -1203,15 +1229,20 @@ void Foam::meshRefinement::findCellZoneGeometric
     const labelList& faceOwner = mesh_.faceOwner();
     const labelList& faceNeighbour = mesh_.faceNeighbour();
 
-    forAll(cellToZone, cellI)
+    // Check if cell centre is inside
+    labelList insideSurfaces;
+    surfaces_.findInside
+    (
+        closedNamedSurfaces,
+        cellCentres,
+        insideSurfaces
+    );
+
+    forAll(insideSurfaces, cellI)
     {
         if (cellToZone[cellI] == -2)
         {
-            label surfI = surfaces_.insideZone
-            (
-                closedNamedSurfaces,
-                cellCentres[cellI]
-            );
+            label surfI = insideSurfaces[cellI];
 
             if (surfI != -1)
             {
@@ -1223,6 +1254,32 @@ void Foam::meshRefinement::findCellZoneGeometric
 
     // Some cells with cell centres close to surface might have
     // had been put into wrong surface. Recheck with perturbed cell centre.
+
+
+    // 1. Collect points
+
+    // Count points to test.
+    label nCandidates = 0;
+    forAll(namedSurfaceIndex, faceI)
+    {
+        label surfI = namedSurfaceIndex[faceI];
+
+        if (surfI != -1)
+        {
+            if (mesh_.isInternalFace(faceI))
+            {
+                nCandidates += 2;
+            }
+            else
+            {
+                nCandidates += 1;
+            }
+        }
+    }
+
+    // Collect points.
+    pointField candidatePoints(nCandidates);
+    nCandidates = 0;
     forAll(namedSurfaceIndex, faceI)
     {
         label surfI = namedSurfaceIndex[faceI];
@@ -1236,55 +1293,65 @@ void Foam::meshRefinement::findCellZoneGeometric
             {
                 label nei = faceNeighbour[faceI];
                 const point& neiCc = cellCentres[nei];
-
+                // Perturbed cc
                 const vector d = 1E-4*(neiCc - ownCc);
+                candidatePoints[nCandidates++] = ownCc-d;
+                candidatePoints[nCandidates++] = neiCc+d;
+            }
+            else
+            {
+                const point& neiFc = mesh_.faceCentres()[faceI];
+                // Perturbed cc
+                const vector d = 1E-4*(neiFc - ownCc);
+                candidatePoints[nCandidates++] = ownCc-d;
+            }
+        }
+    }
 
-                // Test perturbed owner
+
+    // 2. Test points for inside
+
+    surfaces_.findInside
+    (
+        closedNamedSurfaces,
+        candidatePoints,
+        insideSurfaces
+    );
+
+
+    // 3. Update zone information
+
+    nCandidates = 0;
+    forAll(namedSurfaceIndex, faceI)
+    {
+        label surfI = namedSurfaceIndex[faceI];
+
+        if (surfI != -1)
+        {
+            label own = faceOwner[faceI];
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label ownSurfI = insideSurfaces[nCandidates++];
+                if (ownSurfI != -1)
                 {
-                    label ownSurfI = surfaces_.insideZone
-                    (
-                        closedNamedSurfaces,
-                        ownCc-d
-                    );
-
-                    if (ownSurfI != -1)
-                    {
-                        cellToZone[own] = surfaceToCellZone[ownSurfI];
-                    }
+                    cellToZone[own] = surfaceToCellZone[ownSurfI];
                 }
 
-                // Test perturbed neighbour
+                label neiSurfI = insideSurfaces[nCandidates++];
+                if (neiSurfI != -1)
                 {
-                    label neiSurfI = surfaces_.insideZone
-                    (
-                        closedNamedSurfaces,
-                        neiCc+d
-                    );
+                    label nei = faceNeighbour[faceI];
 
-                    if (neiSurfI != -1)
-                    {
-                        cellToZone[nei] = surfaceToCellZone[neiSurfI];
-                    }
+                    cellToZone[nei] = surfaceToCellZone[neiSurfI];
                 }
             }
             else
             {
-                const point& neiCc = mesh_.faceCentres()[faceI];
-
-                const vector d = 1E-4*(neiCc - ownCc);
-
-                // Test perturbed owner
+                label ownSurfI = insideSurfaces[nCandidates++];
+                if (ownSurfI != -1)
                 {
-                    label ownSurfI = surfaces_.insideZone
-                    (
-                        closedNamedSurfaces,
-                        ownCc-d
-                    );
-
-                    if (ownSurfI != -1)
-                    {
-                        cellToZone[own] = surfaceToCellZone[ownSurfI];
-                    }
+                    cellToZone[own] = surfaceToCellZone[ownSurfI];
                 }
             }
         }
@@ -2291,7 +2358,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 
         isNamedSurface[surfI] = true;
 
-        Info<< "Surface : " << surfaces_[surfI].searchableSurface::name() << nl
+        Info<< "Surface : " << surfaces_.names()[surfI] << nl
             << "    faceZone : " << faceZoneNames[surfI] << nl
             << "    cellZone : " << cellZoneNames[surfI] << endl;
     }
@@ -2329,7 +2396,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 
             if (debug)
             {
-                Pout<< "Faces on " << surfaces_[surfI].searchableSurface::name()
+                Pout<< "Faces on " << surfaces_.names()[surfI]
                     << " will go into faceZone " << zoneI << endl;
             }
             surfaceToFaceZone[surfI] = zoneI;
@@ -2387,8 +2454,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 
             if (debug)
             {
-                Pout<< "Cells inside "
-                    << surfaces_[surfI].searchableSurface::name()
+                Pout<< "Cells inside " << surfaces_.names()[surfI]
                     << " will go into cellZone " << zoneI << endl;
             }
             surfaceToCellZone[surfI] = zoneI;
@@ -2444,78 +2510,83 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
         // 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)
+        // do zonify baffle faces anyway (they are normal boundary faces).
+
+        // Collect candidate faces
+        // ~~~~~~~~~~~~~~~~~~~~~~~
+
+        labelList testFaces(intersectedFaces());
+
+        // Collect segments
+        // ~~~~~~~~~~~~~~~~
+
+        pointField start(testFaces.size());
+        pointField end(testFaces.size());
+
+        forAll(testFaces, i)
         {
-            label surfI = surfaceIndex_[faceI];
+            label faceI = testFaces[i];
 
-            if
-            (
-                surfI != -1
-             && (
-                    mesh_.isInternalFace(faceI)
-                 || patches[patches.whichPatch(faceI)].coupled()
-                )
-            )
+            label own = mesh_.faceOwner()[faceI];
+
+            if (mesh_.isInternalFace(faceI))
             {
-                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]++;
-                    }
-                }
+                start[i] = cellCentres[own];
+                end[i] = cellCentres[mesh_.faceNeighbour()[faceI]];
+            }
+            else
+            {
+                start[i] = cellCentres[own];
+                end[i] = neiCc[faceI-mesh_.nInternalFaces()];
             }
         }
 
+
+        // Do test for intersections
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Note that we intersect all intersected faces again. Could reuse
+        // the information already in surfaceIndex_.
+
+        labelList surface1;
+        labelList surface2;
+        {
+            List<pointIndexHit> hit1;
+            labelList region1;
+            List<pointIndexHit> hit2;
+            labelList region2;
+            surfaces_.findNearestIntersection
+            (
+                namedSurfaces,
+                start,
+                end,
+
+                surface1,
+                hit1,
+                region1,
+                surface2,
+                hit2,
+                region2
+            );
+        }
+
+        forAll(testFaces, i)
+        {
+            label faceI = testFaces[i];
+
+            if (surface1[i] != -1)
+            {
+                // If both hit should probably choose nearest. For later.
+                namedSurfaceIndex[faceI] = surface1[i];
+                nSurfFaces[surface1[i]]++;
+            }
+            else if (surface2[i] != -1)
+            {
+                namedSurfaceIndex[faceI] = surface2[i];
+                nSurfFaces[surface2[i]]++;
+            }
+        }
+
+
         // 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
@@ -2534,7 +2605,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
             forAll(nSurfFaces, surfI)
             {
                 Pout<< "Surface:"
-                    << surfaces_[surfI].searchableSurface::name()
+                    << surfaces_.names()[surfI]
                     << "  nZoneFaces:" << nSurfFaces[surfI] << nl;
             }
             Pout<< endl;
@@ -2591,7 +2662,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
                     (
                         mesh_.faces()[faceI],           // modified face
                         faceI,                          // label of face
-                        faceOwner[faceI],              // owner
+                        faceOwner[faceI],               // owner
                         -1,                             // neighbour
                         false,                          // face flip
                         patchI,                         // patch for face
@@ -2609,20 +2680,8 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     // 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);
-
+    // Closed surfaces with cellZone specified.
+    labelList closedNamedSurfaces(surfaces_.getClosedNamedSurfaces());
 
     // Zone per cell:
     // -2 : unset
@@ -2704,13 +2763,4 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 }
 
 
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-
 // ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
index 14c3304979..d8ddb69bce 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
@@ -30,15 +30,9 @@ License
 #include "removePoints.H"
 
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Merge faces that are in-line.
@@ -244,13 +238,4 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeEdges
 }
 
 
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-
 // ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
index bc65921bf5..9a5f6cf633 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementRefine.C
@@ -29,6 +29,7 @@ License
 #include "syncTools.H"
 #include "Time.H"
 #include "refinementSurfaces.H"
+#include "shellSurfaces.H"
 #include "faceSet.H"
 #include "decompositionMethod.H"
 #include "fvMeshDistribute.H"
@@ -37,9 +38,6 @@ License
 #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
@@ -369,7 +367,7 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
             {
                 label edgeI = pEdges[i];
 
-                if (featureEdgeVisited[featI].get(edgeI) == 0)
+                if (featureEdgeVisited[featI].set(edgeI, 1u))
                 {
                     // Unvisited edge. Make the particle go to the other point
                     // on the edge.
@@ -377,7 +375,6 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
                     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;
@@ -438,6 +435,15 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
         }
     }
 
+    if
+    (
+        returnReduce(nRefine, sumOp<label>())
+      > returnReduce(nAllowRefine, sumOp<label>())
+    )
+    {
+        Info<< "Reached refinement limit." << endl;
+    }
+
     return returnReduce(nRefine-oldNRefine,  sumOp<label>());
 }
 
@@ -445,9 +451,6 @@ Foam::label Foam::meshRefinement::markFeatureRefinement
 // 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,
@@ -457,94 +460,113 @@ Foam::label Foam::meshRefinement::markInternalRefinement
     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);
+    // Collect cells to test
+    pointField testCc(cellLevel.size()-nRefine);
+    labelList testLevels(cellLevel.size()-nRefine);
+    label testI = 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;
-            }
+            testCc[testI] = cellCentres[cellI];
+            testLevels[testI] = cellLevel[cellI];
+            testI++;
         }
     }
 
-    Pstream::listCombineGather(nCellsPerShell, plusEqOp<label>());
-    Pstream::listCombineScatter(nCellsPerShell);
+    // Do test to see whether cells is inside/outside shell with higher level
+    labelList maxLevel;
+    shells_.findHigherLevel(testCc, testLevels, maxLevel);
 
-    Info<< "Marked for refinement per shell :" << endl;
-    forAll(nCellsPerShell, shellI)
+    // Mark for refinement. Note that we didn't store the original cellID so
+    // now just reloop in same order.
+    testI = 0;
+    forAll(cellLevel, cellI)
     {
-        Info<< "    shell:" << shellI << " nCells:" << nCellsPerShell[shellI]
-            << nl;
+        if (refineCell[cellI] == -1)
+        {
+            if (maxLevel[testI] > testLevels[testI])
+            {
+                bool reachedLimit = !markForRefine
+                (
+                    maxLevel[testI],    // mark with any positive value
+                    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;
+                }
+            }
+            testI++;
+        }
+    }
+
+    if
+    (
+        returnReduce(nRefine, sumOp<label>())
+      > returnReduce(nAllowRefine, sumOp<label>())
+    )
+    {
+        Info<< "Reached refinement limit." << endl;
     }
 
     return returnReduce(nRefine-oldNRefine, sumOp<label>());
 }
 
 
+// Collect faces that are intersected and whose neighbours aren't yet marked
+// for refinement.
+Foam::labelList Foam::meshRefinement::getRefineCandidateFaces
+(
+    const labelList& refineCell
+) const
+{
+    labelList testFaces(mesh_.nCells());
+
+    label nTest = 0;
+
+    forAll(surfaceIndex_, faceI)
+    {
+        if (surfaceIndex_[faceI] != -1)
+        {
+            label own = mesh_.faceOwner()[faceI];
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label nei = mesh_.faceNeighbour()[faceI];
+
+                if (refineCell[own] == -1 || refineCell[nei] == -1)
+                {
+                    testFaces[nTest++] = faceI;
+                }
+            }
+            else
+            {
+                if (refineCell[own] == -1)
+                {
+                    testFaces[nTest++] = faceI;
+                }
+            }
+        }
+    }
+    testFaces.setSize(nTest);
+
+    return testFaces;
+}
+
+
 // Mark cells for surface intersection based refinement.
 Foam::label Foam::meshRefinement::markSurfaceRefinement
 (
@@ -564,156 +586,149 @@ Foam::label Foam::meshRefinement::markSurfaceRefinement
     // 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++)
+    // Collect candidate faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList testFaces(getRefineCandidateFaces(refineCell));
+
+    // Collect segments
+    // ~~~~~~~~~~~~~~~~
+
+    pointField start(testFaces.size());
+    pointField end(testFaces.size());
+    labelList minLevel(testFaces.size());
+
+    forAll(testFaces, i)
     {
-        if (surfaceIndex_[faceI] != -1)
+        label faceI = testFaces[i];
+
+        label own = mesh_.faceOwner()[faceI];
+
+        if (mesh_.isInternalFace(faceI))
         {
+            label nei = mesh_.faceNeighbour()[faceI];
+
+            start[i] = cellCentres[own];
+            end[i] = cellCentres[nei];
+            minLevel[i] = min(cellLevel[own], cellLevel[nei]);
+        }
+        else
+        {
+            label bFaceI = faceI - mesh_.nInternalFaces();
+
+            start[i] = cellCentres[own];
+            end[i] = neiCc[bFaceI];
+            minLevel[i] = min(cellLevel[own], neiLevel[bFaceI]);
+        }
+    }
+
+
+    // Do test for higher intersections
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList surfaceHit;
+    labelList surfaceMinLevel;
+    surfaces_.findHigherIntersection
+    (
+        start,
+        end,
+        minLevel,
+
+        surfaceHit,
+        surfaceMinLevel
+    );
+
+
+    // Mark cells for refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(testFaces, i)
+    {
+        label faceI = testFaces[i];
+
+        label surfI = surfaceHit[i];
+
+        if (surfI != -1)
+        {
+            // Found intersection with surface with higher wanted
+            // refinement. Check if the level field on that surface
+            // specifies an even higher level. Note:this is weird. Should
+            // do the check with the surfaceMinLevel whilst intersecting the
+            // surfaces?
+
             label own = mesh_.faceOwner()[faceI];
 
+            if (surfaceMinLevel[i] > cellLevel[own])
+            {
+                // Owner needs refining
+                if
+                (
+                   !markForRefine
+                    (
+                        surfI,
+                        nAllowRefine,
+                        refineCell[own],
+                        nRefine
+                    )
+                )
+                {
+                    break;
+                }
+            }
+
             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)
+                if (surfaceMinLevel[i] > cellLevel[nei])
                 {
-                    pointIndexHit hit;
-                    label surfI = surfaces_.findHigherIntersection
+                    // Neighbour needs refining
+                    if
                     (
-                        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)
-                {
-                    // Make sure it is my side that wants refinement.
-                    label surfaceMinLevel =
-                        surfaces_.minLevelField(surfI)[hit.index()];
-                   
-                    if (surfaceMinLevel > cellLevel[own])
-                    {
-                        if
+                       !markForRefine
                         (
-                           !markForRefine
-                            (
-                                surfI,
-                                nAllowRefine,
-                                refineCell[own],
-                                nRefine
-                            )
+                            surfI,
+                            nAllowRefine,
+                            refineCell[nei],
+                            nRefine
                         )
-                        {
-                            break;
-                        }
+                    )
+                    {
+                        break;
                     }
                 }
             }
         }
     }
 
-    if (faceI < surfaceIndex_.size())
+    if
+    (
+        returnReduce(nRefine, sumOp<label>())
+      > returnReduce(nAllowRefine, sumOp<label>())
+    )
     {
-        if (debug)
-        {
-            Pout<< "Stopped refining since reaching my cell limit of "
-                << mesh_.nCells()+7*nRefine << endl;
-        }
+        Info<< "Reached refinement limit." << 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.
+// Checks if multiple intersections of a cell (by a surface with a higher
+// max than the cell level) and if so if the normals at these intersections
+// make a large angle.
+// 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 surfaceLevel,   // current intersection max level
+    const vector& surfaceNormal,// current intersection normal
 
     const label cellI,
 
-    label& maxCellSurfI,
-    label& maxCellTriI,
+    label& cellMaxLevel,        // cached max surface level for this cell
+    vector& cellMaxNormal,      // cached surface normal for this cell
 
     labelList& refineCell,
     label& nRefine
@@ -721,59 +736,35 @@ bool Foam::meshRefinement::checkCurvature
 {
     const labelList& cellLevel = meshCutter_.cellLevel();
 
-    if (maxCellSurfI == -1)
+    // Test if surface applicable
+    if (surfaceLevel > cellLevel[cellI])
     {
-        // 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)
+        if (cellMaxLevel == -1)
         {
-            maxCellSurfI = newSurfI;
-            maxCellTriI = newTriI;
-            maxLevel = surfaces_.maxLevel()[newRegion];
+            // First visit of cell. Store
+            cellMaxLevel = surfaceLevel;
+            cellMaxNormal = surfaceNormal;
         }
-
-
-        // Check if cell is candidate for refinement
-        if (cellLevel[cellI] < maxLevel)
+        else
         {
-            // Test 1: different regions
-            if (markDifferingRegions && cellRegion != newRegion)
+            // Second or more visit. Check curvature.
+            if ((cellMaxNormal & surfaceNormal) < curvature)
             {
                 return markForRefine
                 (
-                    globalToPatch[newRegion],   // mark with non-neg number.
+                    surfaceLevel,   // mark with any 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)
+            // Set normal to that of highest surface. Not really necessary
+            // over here but we reuse cellMax info when doing coupled faces.
+            if (surfaceLevel > cellMaxLevel)
             {
-                return markForRefine
-                (
-                    globalToPatch[newRegion],   // mark with non-neg number.
-                    nAllowRefine,
-                    refineCell[cellI],
-                    nRefine
-                );
+                cellMaxLevel = surfaceLevel;
+                cellMaxNormal = surfaceNormal;
             }
         }
     }
@@ -786,9 +777,7 @@ bool Foam::meshRefinement::checkCurvature
 // 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,
@@ -802,107 +791,117 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
 
     label oldNRefine = nRefine;
 
-    // 1. Any cell on more than one surface gets refined (if its current level
-    // is <= max of the surface max level)
+    // 1. local test: 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.)
+    // 2. 'global' test: any cell on only one surface with a neighbour
+    // on a different surface gets refined (if its current level etc.)
 
 
+    // Collect candidate faces (i.e. intersecting any surface and
+    // owner/neighbour not yet refined.
+    labelList testFaces(getRefineCandidateFaces(refineCell));
 
-    // 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);
+    // Collect segments
+    pointField start(testFaces.size());
+    pointField end(testFaces.size());
+    labelList minLevel(testFaces.size());
 
-    // 1.
-
-    forAll(surfaceIndex_, faceI)
+    forAll(testFaces, i)
     {
-        if (surfaceIndex_[faceI] != -1)
+        label faceI = testFaces[i];
+
+        label own = mesh_.faceOwner()[faceI];
+
+        if (mesh_.isInternalFace(faceI))
         {
+            label nei = mesh_.faceNeighbour()[faceI];
+
+            start[i] = cellCentres[own];
+            end[i] = cellCentres[nei];
+            minLevel[i] = min(cellLevel[own], cellLevel[nei]);
+        }
+        else
+        {
+            label bFaceI = faceI - mesh_.nInternalFaces();
+
+            start[i] = cellCentres[own];
+            end[i] = neiCc[bFaceI];
+            minLevel[i] = min(cellLevel[own], neiLevel[bFaceI]);
+        }
+    }
+
+    // Test for all intersections (with surfaces of higher max level than
+    // minLevel) and cache per cell the max surface level and the local normal
+    // on that surface.
+    labelList cellMaxLevel(mesh_.nCells(), -1);
+    vectorField cellMaxNormal(mesh_.nCells());
+
+    {
+        // Per segment the normals of the surfaces
+        List<vectorList> surfaceNormal;
+        // Per segment the list of levels of the surfaces
+        labelListList surfaceLevel;
+
+        surfaces_.findAllHigherIntersections
+        (
+            start,
+            end,
+            minLevel,           // max level of surface has to be bigger
+                                // than min level of neighbouring cells
+            surfaceNormal,
+            surfaceLevel
+        );
+        // Clear out unnecessary data
+        start.clear();
+        end.clear();
+        minLevel.clear();
+
+        // Extract per cell information on the surface with the highest max
+        forAll(testFaces, i)
+        {
+            label faceI = testFaces[i];
             label own = mesh_.faceOwner()[faceI];
 
-            // There is an intersection. Do more accurate test to get all
-            // intersections
-            labelList surfaceIndices;
-            List<pointIndexHit> hits;
+            const vectorList& fNormals = surfaceNormal[i];
+            const labelList& fLevels = surfaceLevel[i];
+
+            forAll(fLevels, hitI)
+            {
+                checkCurvature
+                (
+                    curvature,
+                    nAllowRefine,
+
+                    fLevels[hitI],
+                    fNormals[hitI],
+
+                    own,
+                    cellMaxLevel[own],
+                    cellMaxNormal[own],
+
+                    refineCell,
+                    nRefine
+                );
+            }
 
             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))
+                forAll(fLevels, hitI)
                 {
-                    label nei = mesh_.faceNeighbour()[faceI];
-
                     checkCurvature
                     (
-                        globalToPatch,
                         curvature,
-                        markDifferingRegions,
                         nAllowRefine,
 
-                        surfI,
-                        triI,
+                        fLevels[hitI],
+                        fNormals[hitI],
 
                         nei,
-
-                        cellMaxSurface[nei],
-                        cellMaxTriangle[nei],
+                        cellMaxLevel[nei],
+                        cellMaxNormal[nei],
 
                         refineCell,
                         nRefine
@@ -910,93 +909,46 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
                 }
             }
         }
-
-        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);
+    labelList neiBndMaxLevel(mesh_.nFaces()-mesh_.nInternalFaces());
+    vectorField neiBndMaxNormal(mesh_.nFaces()-mesh_.nInternalFaces());
+
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        label bFaceI = faceI-mesh_.nInternalFaces();
+        label own = mesh_.faceOwner()[faceI];
+
+        neiBndMaxLevel[bFaceI] = cellMaxLevel[own];
+        neiBndMaxNormal[bFaceI] = cellMaxNormal[own];
+    }
+    syncTools::swapBoundaryFaceList(mesh_, neiBndMaxLevel, false);
+    syncTools::swapBoundaryFaceList(mesh_, neiBndMaxNormal, false);
+
+    // Loop over all faces. Could only be checkFaces.. except if they're coupled
 
     // 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)
+        if (cellMaxLevel[own] != -1 && cellMaxLevel[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)
-            )
+            // Have valid data on both sides. Check curvature.
+            if ((cellMaxNormal[own] & cellMaxNormal[nei]) < curvature)
             {
-                label own = mesh_.faceOwner()[faceI];
-
-                if (cellLevel[own] < surfaces_.maxLevel()[ownRegion[faceI]])
+                // See which side to refine
+                if (cellLevel[own] < cellMaxLevel[own])
                 {
                     if
                     (
                         !markForRefine
                         (
-                            globalToPatch[ownRegion[faceI]],
+                            cellMaxLevel[own],
                             nAllowRefine,
                             refineCell[own],
                             nRefine
@@ -1011,46 +963,77 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
                         }
                         break;
                     }
-
                 }
 
-                if (mesh_.isInternalFace(faceI))
+                if (cellLevel[nei] < cellMaxLevel[nei])
                 {
-                    label nei = mesh_.faceNeighbour()[faceI];
-
-                    if (cellLevel[nei] < surfaces_.maxLevel()[neiRegion[faceI]])
-                    {
-                        if
+                    if
+                    (
+                        !markForRefine
                         (
-                            !markForRefine
-                            (
-                                globalToPatch[neiRegion[faceI]],
-                                nAllowRefine,
-
-                                refineCell[nei],
-                                nRefine
-                            )
+                            cellMaxLevel[nei],
+                            nAllowRefine,
+                            refineCell[nei],
+                            nRefine
                         )
+                    )
+                    {
+                        if (debug)
                         {
-                            if (debug)
-                            {
-                                Pout<< "Stopped refining since reaching my cell"
-                                    << " limit of " << mesh_.nCells()+7*nRefine
-                                    << endl;
-                            }
-                            break;
+                            Pout<< "Stopped refining since reaching my cell"
+                                << " limit of " << mesh_.nCells()+7*nRefine
+                                << endl;
                         }
+                        break;
                     }
                 }
             }
         }
     }
+    // Boundary faces
+    for (label faceI = mesh_.nInternalFaces(); faceI < mesh_.nFaces(); faceI++)
+    {
+        label own = mesh_.faceOwner()[faceI];
+        label bFaceI = faceI - mesh_.nInternalFaces();
 
+        if (cellLevel[own] < cellMaxLevel[own] && neiBndMaxLevel[bFaceI] != -1)
+        {
+            // Have valid data on both sides. Check curvature.
+            if ((cellMaxNormal[own] & neiBndMaxNormal[bFaceI]) < curvature)
+            {
+                if
+                (
+                    !markForRefine
+                    (
+                        cellMaxLevel[own],
+                        nAllowRefine,
+                        refineCell[own],
+                        nRefine
+                    )
+                )
+                {
+                    if (debug)
+                    {
+                        Pout<< "Stopped refining since reaching my cell"
+                            << " limit of " << mesh_.nCells()+7*nRefine
+                            << endl;
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    if
+    (
+        returnReduce(nRefine, sumOp<label>())
+      > returnReduce(nAllowRefine, sumOp<label>())
+    )
+    {
+        Info<< "Reached refinement limit." << endl;
+    }
 
     return returnReduce(nRefine-oldNRefine, sumOp<label>());
-    label totNRefined = returnReduce(totNRefined, sumOp<label>());
-
-    return totNRefined;
 }
 
 
@@ -1064,16 +1047,11 @@ Foam::label Foam::meshRefinement::markSurfaceCurvatureRefinement
 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,
@@ -1086,7 +1064,12 @@ Foam::labelList Foam::meshRefinement::refineCandidates
 
     labelList cellsToRefine;
 
-    if (totNCells < maxGlobalCells)
+    if (totNCells >= maxGlobalCells)
+    {
+        Info<< "No cells marked for refinement since reached limit "
+            << maxGlobalCells << '.' << endl;
+    }
+    else
     {
         // Every cell I refine adds 7 cells. Estimate the number of cells
         // I am allowed to refine.
@@ -1151,9 +1134,6 @@ Foam::labelList Foam::meshRefinement::refineCandidates
         {
             label nShell = markInternalRefinement
             (
-                shells,
-                shellLevels,
-                shellRefineInside,
                 nAllowRefine,
 
                 refineCell,
@@ -1184,13 +1164,11 @@ Foam::labelList Foam::meshRefinement::refineCandidates
         // Refinement based on curvature of surface
         // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-        if (curvatureRefinement)
+        if (curvatureRefinement && (curvature >= -1 && curvature <= 1))
         {
             label nCurv = markSurfaceCurvatureRefinement
             (
-                globalToPatch,
                 curvature,
-                false,              // do not refine at multiple regions
                 nAllowRefine,
                 neiLevel,
                 neiCc,
@@ -1287,28 +1265,6 @@ Foam::autoPtr<Foam::mapDistributePolyMesh>
     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
     // ~~~~~~~~~~~~~~
 
diff --git a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
index 83816314a7..ce09e597e2 100644
--- a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
+++ b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
@@ -27,39 +27,31 @@ License
 #include "refinementSurfaces.H"
 #include "orientedSurface.H"
 #include "Time.H"
-#include "searchableSurface.H"
+#include "searchableSurfaces.H"
+#include "shellSurfaces.H"
+#include "triSurfaceMesh.H"
+#include "labelPair.H"
+#include "searchableSurfacesQueries.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 searchableSurfaces& allGeometry,
     const PtrList<dictionary>& surfaceDicts
 )
 :
-    triSurfaceMeshes(io, extractFileNames(surfaceDicts)),
+    allGeometry_(allGeometry),
+    surfaces_(surfaceDicts.size()),
     names_(surfaceDicts.size()),
-    closed_(surfaceDicts.size(), true),
     faceZoneNames_(surfaceDicts.size()),
     cellZoneNames_(surfaceDicts.size()),
     zoneInside_(surfaceDicts.size()),
@@ -67,29 +59,25 @@ Foam::refinementSurfaces::refinementSurfaces
 {
     labelList globalMinLevel(surfaceDicts.size(), 0);
     labelList globalMaxLevel(surfaceDicts.size(), 0);
-    List<HashTable<label> > regionMinLevel(surfaceDicts.size());
-    List<HashTable<label> > regionMaxLevel(surfaceDicts.size());
+    List<Map<label> > regionMinLevel(surfaceDicts.size());
+    List<Map<label> > regionMaxLevel(surfaceDicts.size());
 
-    labelList globalSurfLayers(surfaceDicts.size());
-    List<HashTable<label> > regionSurfLayers(surfaceDicts.size());
-
-    wordList globalPatchType(surfaceDicts.size());
-    List<HashTable<word> > regionPatchType(surfaceDicts.size());
-    List<HashTable<word> > regionPatchName(surfaceDicts.size());
+    //wordList globalPatchType(surfaceDicts.size());
+    //List<HashTable<word> > regionPatchType(surfaceDicts.size());
+    //List<HashTable<word> > regionPatchName(surfaceDicts.size());
 
     forAll(surfaceDicts, surfI)
     {
         const dictionary& dict = surfaceDicts[surfI];
 
-        names_[surfI] = word(dict.lookup("name"));
+        dict.lookup("name") >> names_[surfI];
+
+        surfaces_[surfI] = allGeometry_.findSurfaceID(names_[surfI]);
 
         // Global refinement level
         globalMinLevel[surfI] = readLabel(dict.lookup("minRefinementLevel"));
         globalMaxLevel[surfI] = readLabel(dict.lookup("maxRefinementLevel"));
 
-        // Global number of layers
-        globalSurfLayers[surfI] = readLabel(dict.lookup("surfaceLayers"));
-
         // Global zone names per surface
         if (dict.found("faceZone"))
         {
@@ -98,50 +86,62 @@ Foam::refinementSurfaces::refinementSurfaces
             dict.lookup("zoneInside") >> zoneInside_[surfI];
         }
 
-        // Global patch name per surface
-        if (dict.found("patchType"))
-        {
-            dict.lookup("patchType") >> globalPatchType[surfI];
-        }
+        //// Global patch name per surface
+        //if (dict.found("patchType"))
+        //{
+        //    dict.lookup("patchType") >> globalPatchType[surfI];
+        //}
 
 
         if (dict.found("regions"))
         {
             PtrList<dictionary> regionDicts(dict.lookup("regions"));
 
+            const wordList& regionNames =
+                allGeometry_[surfaces_[surfI]].regions();
+
             forAll(regionDicts, dictI)
             {
                 const dictionary& regionDict = regionDicts[dictI];
 
                 const word regionName(regionDict.lookup("name"));
+
+                label regionI = findIndex(regionNames, regionName);
+
+                if (regionI == -1)
+                {
+                    FatalErrorIn
+                    (
+                        "refinementSurfaces::refinementSurfaces"
+                        "(const IOobject&, const PtrList<dictionary>&)"
+                    )   << "No region called " << regionName << " on surface "
+                        << allGeometry_[surfaces_[surfI]].name() << endl
+                        << "Valid regions are " << regionNames
+                        << exit(FatalError);
+                }
+
+
                 label min = readLabel(regionDict.lookup("minRefinementLevel"));
                 label max = readLabel(regionDict.lookup("maxRefinementLevel"));
 
-                regionMinLevel[surfI].insert(regionName, min);
-                regionMaxLevel[surfI].insert(regionName, max);
-
-                label nLayers = readLabel(regionDict.lookup("surfaceLayers"));
-                regionSurfLayers[surfI].insert(regionName, nLayers);
-
-                if (regionDict.found("patchType"))
+                bool hasInserted = regionMinLevel[surfI].insert(regionI, min);
+                if (!hasInserted)
                 {
-                    regionPatchType[surfI].insert
+                    FatalErrorIn
                     (
-                        regionName,
-                        regionDict.lookup("patchType")
-                    );
-                    regionPatchName[surfI].insert
-                    (
-                        regionName,
-                        regionDict.lookup("patchName")
-                    );
+                        "refinementSurfaces::refinementSurfaces"
+                        "(const IOobject&, const PtrList<dictionary>&)"
+                    )   << "Duplicate region name " << regionName
+                        << " on surface " << names_[surfI]
+                        << exit(FatalError);
                 }
+                regionMaxLevel[surfI].insert(regionI, max);
             }
         }
     }
 
 
-    // Check for duplicate surface or region names
+    // Check for duplicate surface names
     {
         HashTable<label> surfaceNames(names_.size());
 
@@ -158,49 +158,9 @@ Foam::refinementSurfaces::refinementSurfaces
                     << surfaceNames[names_[surfI]]
                     << exit(FatalError);
             }
-
-            // Check for duplicate region names
-            const geometricSurfacePatchList& patches =
-                operator[](surfI).patches();
-
-            HashTable<label> regionNames(patches.size());
-            forAll(patches, i)
-            {
-                if (!regionNames.insert(patches[i].name(), i))
-                {
-                    FatalErrorIn
-                    (
-                        "refinementSurfaces::refinementSurfaces"
-                        "(const IOobject&, const PtrList<dictionary>&)"
-                    )   << "Duplicate region name " << patches[i].name()
-                        << " on surface " << names_[surfI] << endl
-                        << "Previous occurrence of region at index "
-                        << regionNames[patches[i].name()]
-                        << exit(FatalError);
-                }
-            }
         }
     }
 
-
-    // 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;
 
@@ -208,7 +168,7 @@ Foam::refinementSurfaces::refinementSurfaces
     {
         regionOffset_[surfI] = nRegions;
 
-        nRegions += operator[](surfI).patches().size();
+        nRegions += allGeometry_[surfaces_[surfI]].regions().size();
     }
 
     // Rework surface specific information into information per global region
@@ -216,61 +176,33 @@ Foam::refinementSurfaces::refinementSurfaces
     minLevel_ = 0;
     maxLevel_.setSize(nRegions);
     maxLevel_ = 0;
-    numLayers_.setSize(nRegions);
-    numLayers_ = 0;
-    patchName_.setSize(nRegions);
-    patchType_.setSize(nRegions);
+    //patchName_.setSize(nRegions);
+    //patchType_.setSize(nRegions);
 
     forAll(surfaceDicts, surfI)
     {
-        const geometricSurfacePatchList& regions = operator[](surfI).patches();
+        label nRegions = allGeometry_[surfaces_[surfI]].regions().size();
 
         // Initialise to global (i.e. per surface)
-        forAll(regions, i)
+        for (label i = 0; i < nRegions; i++)
         {
             minLevel_[regionOffset_[surfI] + i] = globalMinLevel[surfI];
             maxLevel_[regionOffset_[surfI] + i] = globalMaxLevel[surfI];
-            numLayers_[regionOffset_[surfI] + i] = globalSurfLayers[surfI];
-            patchType_[regionOffset_[surfI] + i] = globalPatchType[surfI];
-        }
-
-        // Get the region names
-        wordList regionNames(regions.size());
-        forAll(regions, regionI)
-        {
-            regionNames[regionI] = regions[regionI].name();
         }
 
         // Overwrite with region specific information
-        forAllConstIter(HashTable<label>, regionMinLevel[surfI], iter)
+        forAllConstIter(Map<label>, regionMinLevel[surfI], iter)
         {
-            // Find the local region number.
-            label regionI = findIndex(regionNames, iter.key());
-
-            if (regionI == -1)
-            {
-                FatalErrorIn
-                (
-                    "refinementSurfaces::refinementSurfaces"
-                    "(const IOobject&, const PtrList<dictionary>&)"
-                )   << "Cannot find region " << iter.key()
-                    << " in surface " << names_[surfI]
-                    << " which has regions " << regionNames
-                    << abort(FatalError);
-            }
-
-            label globalRegionI = regionOffset_[surfI] + regionI;
+            label globalRegionI = regionOffset_[surfI] + iter.key();
 
             minLevel_[globalRegionI] = iter();
             maxLevel_[globalRegionI] = regionMaxLevel[surfI][iter.key()];
-            numLayers_[globalRegionI] = regionSurfLayers[surfI][iter.key()];
 
             // Check validity
             if
             (
                 minLevel_[globalRegionI] < 0
              || maxLevel_[globalRegionI] < minLevel_[globalRegionI]
-             || numLayers_[globalRegionI] < 0
             )
             {
                 FatalErrorIn
@@ -281,19 +213,163 @@ Foam::refinementSurfaces::refinementSurfaces
                     << names_[surfI]
                     << " : minLevel:" << minLevel_[globalRegionI]
                     << " maxLevel:" << maxLevel_[globalRegionI]
-                    << " numLayers:" << numLayers_[globalRegionI]
                     << exit(FatalError);
             }
         }
 
-        // Optional patch names and patch types
-        forAllConstIter(HashTable<word>, regionPatchName[surfI], iter)
-        {
-            label regionI = findIndex(regionNames, iter.key());
-            label globalRegionI = regionOffset_[surfI] + regionI;
+        //// Optional patch names and patch types
+        //forAllConstIter(HashTable<word>, regionPatchName[surfI], iter)
+        //{
+        //    label regionI = findIndex(regionNames, iter.key());
+        //    label globalRegionI = regionOffset_[surfI] + regionI;
+        //
+        //    patchName_[globalRegionI] = iter();
+        //    patchType_[globalRegionI] = regionPatchType[surfI][iter.key()];
+        //}
+    }
+}
 
-            patchName_[globalRegionI] = iter();
-            patchType_[globalRegionI] = regionPatchType[surfI][iter.key()];
+
+Foam::refinementSurfaces::refinementSurfaces
+(
+    const searchableSurfaces& allGeometry,
+    const dictionary& surfacesDict
+)
+:
+    allGeometry_(allGeometry),
+    surfaces_(surfacesDict.size()),
+    names_(surfacesDict.size()),
+    faceZoneNames_(surfacesDict.size()),
+    cellZoneNames_(surfacesDict.size()),
+    zoneInside_(surfacesDict.size()),
+    regionOffset_(surfacesDict.size())
+{
+    labelList globalMinLevel(surfacesDict.size(), 0);
+    labelList globalMaxLevel(surfacesDict.size(), 0);
+    List<Map<label> > regionMinLevel(surfacesDict.size());
+    List<Map<label> > regionMaxLevel(surfacesDict.size());
+
+    label surfI = 0;
+    forAllConstIter(dictionary, surfacesDict, iter)
+    {
+        names_[surfI] = iter().keyword();
+
+        surfaces_[surfI] = allGeometry_.findSurfaceID(names_[surfI]);
+
+        if (surfaces_[surfI] == -1)
+        {
+            FatalErrorIn
+            (
+                "refinementSurfaces::refinementSurfaces"
+                "(const searchableSurfaces&, const dictionary>&"
+            )   << "No surface called " << iter().keyword() << endl
+                << "Valid surfaces are " << allGeometry_.names()
+                << exit(FatalError);
+        }
+        const dictionary& dict = surfacesDict.subDict(iter().keyword());
+
+        const labelPair refLevel(dict.lookup("level"));
+        globalMinLevel[surfI] = refLevel[0];
+        globalMaxLevel[surfI] = refLevel[1];
+
+        // Global zone names per surface
+        if (dict.found("faceZone"))
+        {
+            dict.lookup("faceZone") >> faceZoneNames_[surfI];
+            dict.lookup("cellZone") >> cellZoneNames_[surfI];
+            dict.lookup("zoneInside") >> zoneInside_[surfI];
+        }
+
+        if (dict.found("regions"))
+        {
+            const dictionary& regionsDict = dict.subDict("regions");
+            const wordList& regionNames =
+                allGeometry_[surfaces_[surfI]].regions();
+
+            forAllConstIter(dictionary, regionsDict, iter)
+            {
+                const word& key = iter().keyword();
+
+                if (regionsDict.isDict(key))
+                {
+                    // Get the dictionary for region iter.keyword()
+                    const dictionary& regionDict = regionsDict.subDict(key);
+
+                    label regionI = findIndex(regionNames, key);
+                    if (regionI == -1)
+                    {
+                        FatalErrorIn
+                        (
+                            "refinementSurfaces::refinementSurfaces"
+                            "(const searchableSurfaces&, const dictionary>&"
+                        )   << "No region called " << key << " on surface "
+                            << allGeometry_[surfaces_[surfI]].name() << endl
+                            << "Valid regions are " << regionNames
+                            << exit(FatalError);
+                    }
+
+                    const labelPair refLevel(regionDict.lookup("level"));
+
+                    regionMinLevel[surfI].insert(regionI, refLevel[0]);
+                    regionMaxLevel[surfI].insert(regionI, refLevel[1]);
+                }
+            }
+        }
+        surfI++;
+    }
+
+    // Calculate local to global region offset
+    label nRegions = 0;
+
+    forAll(surfacesDict, surfI)
+    {
+        regionOffset_[surfI] = nRegions;
+        nRegions += allGeometry_[surfaces_[surfI]].regions().size();
+    }
+
+    // Rework surface specific information into information per global region
+    minLevel_.setSize(nRegions);
+    minLevel_ = 0;
+    maxLevel_.setSize(nRegions);
+    maxLevel_ = 0;
+
+
+    forAll(globalMinLevel, surfI)
+    {
+        label nRegions = allGeometry_[surfaces_[surfI]].regions().size();
+
+        // Initialise to global (i.e. per surface)
+        for (label i = 0; i < nRegions; i++)
+        {
+            minLevel_[regionOffset_[surfI] + i] = globalMinLevel[surfI];
+            maxLevel_[regionOffset_[surfI] + i] = globalMaxLevel[surfI];
+        }
+
+        // Overwrite with region specific information
+        forAllConstIter(Map<label>, regionMinLevel[surfI], iter)
+        {
+            label globalRegionI = regionOffset_[surfI] + iter.key();
+
+            minLevel_[globalRegionI] = iter();
+            maxLevel_[globalRegionI] = regionMaxLevel[surfI][iter.key()];
+
+            // Check validity
+            if
+            (
+                minLevel_[globalRegionI] < 0
+             || maxLevel_[globalRegionI] < minLevel_[globalRegionI]
+            )
+            {
+                FatalErrorIn
+                (
+                    "refinementSurfaces::refinementSurfaces"
+                    "(const searchableSurfaces&, const dictionary>&"
+                )   << "Illegal level or layer specification for surface "
+                    << names_[surfI]
+                    << " : minLevel:" << minLevel_[globalRegionI]
+                    << " maxLevel:" << maxLevel_[globalRegionI]
+                    << exit(FatalError);
+            }
         }
     }
 }
@@ -301,7 +377,7 @@ Foam::refinementSurfaces::refinementSurfaces
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-//- Get indices of named surfaces (surfaces with cellZoneNam)
+// Get indices of named surfaces (surfaces with cellZoneName)
 Foam::labelList Foam::refinementSurfaces::getNamedSurfaces() const
 {
    labelList namedSurfaces(cellZoneNames_.size());
@@ -320,16 +396,26 @@ Foam::labelList Foam::refinementSurfaces::getNamedSurfaces() const
 }
 
 
-bool Foam::refinementSurfaces::isSurfaceClosed(const triSurface& s)
+// Get indices of closed named surfaces
+Foam::labelList Foam::refinementSurfaces::getClosedNamedSurfaces() const
 {
-    if (s.nEdges() == s.nInternalEdges())
+    labelList named(getNamedSurfaces());
+
+    labelList closed(named.size());
+    label closedI = 0;
+
+    forAll(named, i)
     {
-        return true;
-    }
-    else
-    {
-        return false;
+        label surfI = named[i];
+
+        if (allGeometry_[surfaces_[surfI]].hasVolumeType())
+        {
+            closed[closedI++] = surfI;
+        }
     }
+    closed.setSize(closedI);
+
+    return closed;
 }
 
 
@@ -373,238 +459,475 @@ Foam::labelList Foam::refinementSurfaces::countRegions(const triSurface& s)
 }
 
 
+// Precalculate the refinement level for every element of the searchable
+// surface. This is currently hardcoded for triSurfaceMesh only.
+void Foam::refinementSurfaces::setMinLevelFields
+(
+    const shellSurfaces& shells
+)
+{
+    minLevelFields_.setSize(surfaces_.size());
+
+    forAll(surfaces_, surfI)
+    {
+        const searchableSurface& geom = allGeometry_[surfaces_[surfI]];
+
+        if (isA<triSurfaceMesh>(geom))
+        {
+            const triSurfaceMesh& triMesh = refCast<const triSurfaceMesh>(geom);
+
+            minLevelFields_.set
+            (
+                surfI,
+                new triSurfaceLabelField
+                (
+                    IOobject
+                    (
+                        triMesh.searchableSurface::name(),
+                        triMesh.objectRegistry::time().constant(),// directory
+                        "triSurface",               // instance
+                        triMesh,
+                        IOobject::NO_READ,
+                        IOobject::AUTO_WRITE,
+                        false
+                    ),
+                    triMesh,
+                    dimless
+                )
+            );
+            triSurfaceLabelField& minLevelField = minLevelFields_[surfI];
+
+            const triSurface& s = static_cast<const triSurface&>(triMesh);
+
+            // Initialise fields to region wise minLevel
+            forAll(s, triI)
+            {
+                minLevelField[triI] = minLevel(surfI, s[triI].region());
+            }
+
+            // Find out if triangle inside shell with higher level
+            pointField fc(s.size());
+            forAll(s, triI)
+            {
+                fc[triI] = s[triI].centre(s.points());
+            }
+            // What level does shell want to refine fc to?
+            labelList shellLevel;
+            shells.findHigherLevel(fc, minLevelField, shellLevel);
+
+            forAll(minLevelField, triI)
+            {
+                minLevelField[triI] = max
+                (
+                    minLevelField[triI],
+                    shellLevel[triI]
+                );
+            }
+        }
+    }
+}
+
+
 // Find intersections of edge. Return -1 or first surface with higher minLevel
 // number.
-Foam::label Foam::refinementSurfaces::findHigherIntersection
+void Foam::refinementSurfaces::findHigherIntersection
 (
-    const point& start,
-    const point& end,
-    const label currentLevel,   // current cell refinement level
+    const pointField& start,
+    const pointField& end,
+    const labelList& currentLevel,   // current cell refinement level
 
-    pointIndexHit& hit
+    labelList& surfaces,
+    labelList& surfaceLevel
 ) const
 {
-    forAll(*this, surfI)
-    {
-        hit = operator[](surfI).findLineAny(start, end);
+    surfaces.setSize(start.size());
+    surfaces = -1;
+    surfaceLevel.setSize(start.size());
+    surfaceLevel = -1;
 
-        if (hit.hit())
+    if (surfaces_.size() == 0)
+    {
+        return;
+    }
+
+    // Work arrays
+    labelList hitMap(identity(start.size()));
+    pointField p0(start);
+    pointField p1(end);
+    List<pointIndexHit> hitInfo(start.size());
+
+
+    forAll(surfaces_, surfI)
+    {
+        allGeometry_[surfaces_[surfI]].findLineAny(p0, p1, hitInfo);
+
+        // Copy all hits into arguments, continue with misses
+        label newI = 0;
+        forAll(hitInfo, hitI)
         {
-            if (currentLevel == -1)
+            // Get the minLevel for the point
+            label minLocalLevel = -1;
+
+            if (hitInfo[hitI].hit())
             {
-                // Return any.
-                return surfI;
+                // Check if minLevelField for this surface.
+                if
+                (
+                    minLevelFields_.set(surfI)
+                 && minLevelFields_[surfI].size() > 0
+                )
+                {
+                    minLocalLevel =
+                        minLevelFields_[surfI][hitInfo[hitI].index()];
+                }
+                else
+                {
+                    // Use the min level for the surface instead. Assume
+                    // single region 0. 
+                    minLocalLevel = minLevel(surfI, 0);
+                }
+            }
+
+            label pointI = hitMap[hitI];
+
+            if (minLocalLevel > currentLevel[pointI])
+            {
+                surfaces[pointI] = surfI;
+                surfaceLevel[pointI] = minLocalLevel;
             }
             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)
+                if (hitI != newI)
                 {
-                    return surfI;
+                    hitMap[newI] = hitMap[hitI];
+                    p0[newI] = p0[hitI];
+                    p1[newI] = p1[hitI];
+                }
+                newI++;
+            }
+        }
+
+        // All done? Note that this decision should be synchronised
+        if (newI == 0)
+        {
+            break;
+        }
+
+        // Trim and continue
+        hitMap.setSize(newI);
+        p0.setSize(newI);
+        p1.setSize(newI);
+        hitInfo.setSize(newI);
+    }
+}
+
+
+void Foam::refinementSurfaces::findAllHigherIntersections
+(
+    const pointField& start,
+    const pointField& end,
+    const labelList& currentLevel,   // current cell refinement level
+
+    List<vectorList>& surfaceNormal,
+    labelListList& surfaceLevel
+) const
+{
+    surfaceLevel.setSize(start.size());
+    surfaceNormal.setSize(start.size());
+
+    if (surfaces_.size() == 0)
+    {
+        return;
+    }
+
+    // Work arrays
+    List<List<pointIndexHit> > hitInfo;
+    labelList pRegions;
+    vectorField pNormals;
+
+    forAll(surfaces_, surfI)
+    {
+        allGeometry_[surfaces_[surfI]].findLineAll(start, end, hitInfo);
+
+        forAll(hitInfo, pointI)
+        {
+            const List<pointIndexHit>& pHits = hitInfo[pointI];
+            allGeometry_[surfaces_[surfI]].getRegion(pHits, pRegions);
+            allGeometry_[surfaces_[surfI]].getNormal(pHits, pNormals);
+
+            // Extract those hits that are on higher levelled surfaces.
+            // Note: should move extraction of region, normal outside of loop
+            // below for if getRegion/getNormal have high overhead.
+
+            forAll(pHits, pHitI)
+            {
+                label region = globalRegion(surfI, pRegions[pHitI]);
+
+                if (maxLevel_[region] > currentLevel[pointI])
+                {
+                    // Append to pointI info
+                    label sz = surfaceNormal[pointI].size();
+                    surfaceNormal[pointI].setSize(sz+1);
+                    surfaceNormal[pointI][sz] = pNormals[pHitI];
+
+                    surfaceLevel[pointI].setSize(sz+1);
+                    surfaceLevel[pointI][sz] = maxLevel_[region];
                 }
             }
         }
     }
-
-    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
+void Foam::refinementSurfaces::findNearestIntersection
 (
-    const point& start,
-    const point& end,
-    const label currentLevel,   // current cell refinement level
+    const labelList& surfacesToTest,
+    const pointField& start,
+    const pointField& end,
 
-    pointIndexHit& maxHit
+    labelList& surface1,
+    List<pointIndexHit>& hit1,
+    labelList& region1,
+    labelList& surface2,
+    List<pointIndexHit>& hit2,
+    labelList& region2
 ) const
 {
-    // surface with highest maxlevel
-    label maxSurface = -1;
-    // maxLevel of maxSurface
-    label maxLevel = currentLevel;
+    // 1. intersection from start to end
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    forAll(*this, surfI)
+    // Initialize arguments
+    surface1.setSize(start.size());
+    surface1 = -1;
+    hit1.setSize(start.size());
+    region1.setSize(start.size());
+
+    // Current end of segment to test.
+    pointField nearest(end);
+    // Work array
+    List<pointIndexHit> nearestInfo(start.size());
+    labelList region;
+
+    forAll(surfacesToTest, testI)
     {
-        pointIndexHit hit = operator[](surfI).findLineAny(start, end);
+        label surfI = surfacesToTest[testI];
 
-        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
+        // See if any intersection between start and current nearest
+        allGeometry_[surfaces_[surfI]].findLine
         (
-            surfI,
-            new triSurfaceLabelField
-            (
-                IOobject
-                (
-                    surfMesh.IOobject::name(),
-                    surfMesh.time().constant(), // directory
-                    "triSurface",               // instance
-                    surfMesh,
-                    IOobject::NO_READ,
-                    IOobject::AUTO_WRITE,
-                    false
-                ),
-                surfMesh,
-                dimless
-            )
+            start,
+            nearest,
+            nearestInfo
+        );
+        allGeometry_[surfaces_[surfI]].getRegion
+        (
+            nearestInfo,
+            region
         );
-    }
 
-    // Initialise fields to region wise minLevel
-    forAll(*this, surfI)
-    {
-        const triSurface& s = operator[](surfI);
-
-        triSurfaceLabelField& minLevelField = minLevelFields_[surfI];
-
-        forAll(s, i)
+        forAll(nearestInfo, pointI)
         {
-            minLevelField[i] = minLevel_[globalRegion(surfI, s[i].region())];
+            if (nearestInfo[pointI].hit())
+            {
+                hit1[pointI] = nearestInfo[pointI];
+                surface1[pointI] = surfI;
+                region1[pointI] = region[pointI];
+                nearest[pointI] = hit1[pointI].hitPoint();
+            }
         }
     }
 
-    // Adapt for triangles inside shells
-    forAll(*this, surfI)
+
+    // 2. intersection from end to last intersection
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Find the nearest intersection from end to start. Note that we initialize
+    // to the first intersection (if any).
+    surface2 = surface1;
+    hit2 = hit1;
+    region2 = region1;
+
+    // Set current end of segment to test.
+    forAll(nearest, pointI)
     {
-        const triSurface& s = operator[](surfI);
-        triSurfaceLabelField& minLevelField = minLevelFields_[surfI];
-
-        forAll(s, i)
+        if (hit1[pointI].hit())
         {
-            point fc = s[i].centre(s.points());
+            nearest[pointI] = hit1[pointI].hitPoint();
+        }
+        else
+        {
+            // Disable testing by setting to end.
+            nearest[pointI] = end[pointI];
+        }
+    }
 
-            forAll(shells, shellI)
+    forAll(surfacesToTest, testI)
+    {
+        label surfI = surfacesToTest[testI];
+
+        // See if any intersection between end and current nearest
+        allGeometry_[surfaces_[surfI]].findLine
+        (
+            end,
+            nearest,
+            nearestInfo
+        );
+        allGeometry_[surfaces_[surfI]].getRegion
+        (
+            nearestInfo,
+            region
+        );
+
+        forAll(nearestInfo, pointI)
+        {
+            if (nearestInfo[pointI].hit())
             {
-                // Which side of shell is to be refined
-                searchableSurface::volumeType refSide =
-                (
-                    shellRefineInside[shellI]
-                  ? searchableSurface::INSIDE
-                  : searchableSurface::OUTSIDE
-                );
+                hit2[pointI] = nearestInfo[pointI];
+                surface2[pointI] = surfI;
+                region2[pointI] = region[pointI];
+                nearest[pointI] = hit2[pointI].hitPoint();
+            }
+        }
+    }
+}
 
-                // Find whether point is inside or outside shell
-                searchableSurface::volumeType t =
-                    shells[shellI].getVolumeType(fc);
 
-                if (t == refSide)
+void Foam::refinementSurfaces::findAnyIntersection
+(
+    const pointField& start,
+    const pointField& end,
+
+    labelList& hitSurface,
+    List<pointIndexHit>& hitInfo
+) const
+{
+    searchableSurfacesQueries::findAnyIntersection
+    (
+        allGeometry_,
+        surfaces_,
+        start,
+        end,
+        hitSurface,
+        hitInfo
+    );
+}
+
+
+void Foam::refinementSurfaces::findNearest
+(
+    const labelList& surfacesToTest,
+    const pointField& samples,
+    const  scalarField& nearestDistSqr,
+    labelList& hitSurface,
+    List<pointIndexHit>& hitInfo
+) const
+{
+    labelList geometries(IndirectList<label>(surfaces_, surfacesToTest));
+
+    // Do the tests. Note that findNearest returns index in geometries.
+    searchableSurfacesQueries::findNearest
+    (
+        allGeometry_,
+        geometries,
+        samples,
+        nearestDistSqr,
+        hitSurface,
+        hitInfo
+    );
+
+    // Rework the hitSurface to be surface (i.e. index into surfaces_)
+    forAll(hitSurface, pointI)
+    {
+        if (hitSurface[pointI] != -1)
+        {
+            hitSurface[pointI] = surfacesToTest[hitSurface[pointI]];
+        }
+    }
+}
+
+
+//// 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;
+//}
+
+
+void Foam::refinementSurfaces::findInside
+(
+    const labelList& testSurfaces,
+    const pointField& pt,
+    labelList& insideSurfaces
+) const
+{
+    insideSurfaces.setSize(pt.size());
+    insideSurfaces = -1;
+
+    forAll(testSurfaces, i)
+    {
+        label surfI = testSurfaces[i];
+
+        if (allGeometry_[surfaces_[surfI]].hasVolumeType())
+        {
+            List<searchableSurface::volumeType> volType;
+            allGeometry_[surfaces_[surfI]].getVolumeType(pt, volType);
+
+            forAll(volType, pointI)
+            {
+                if (insideSurfaces[pointI] == -1)
                 {
-                    minLevelField[i] = max
+                    if
                     (
-                        minLevelField[i],
-                        shellLevels[shellI]
-                    );
+                        (
+                            volType[pointI] == triSurfaceMesh::INSIDE
+                         && zoneInside_[surfI]
+                        )
+                     || (
+                            volType[pointI] == triSurfaceMesh::OUTSIDE
+                         && !zoneInside_[surfI]
+                        )
+                    )
+                    {
+                        insideSurfaces[pointI] = surfI;
+                    }
                 }
             }
         }
diff --git a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
index dc5bd0adfb..b7cbc91696 100644
--- a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
+++ b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
@@ -38,34 +38,38 @@ SourceFiles
 #ifndef refinementSurfaces_H
 #define refinementSurfaces_H
 
-#include "triSurfaceMeshes.H"
 #include "PackedList.H"
 #include "triSurfaceGeoMesh.H"
 #include "triSurfaceFields.H"
+#include "vectorList.H"
+#include "pointIndexHit.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-class searchableSurface;
+class searchableSurfaces;
+class shellSurfaces;
+class triSurfaceMesh;
 
 /*---------------------------------------------------------------------------*\
                            Class refinementSurfaces Declaration
 \*---------------------------------------------------------------------------*/
 
 class refinementSurfaces
-:
-    public triSurfaceMeshes
 {
     // Private data
 
+        //- Reference to all geometry.
+        const searchableSurfaces& allGeometry_;
+
+        //- Indices of surfaces that are refinement ones
+        labelList surfaces_;
+
         //- Surface name (word)
         wordList names_;
 
-        //- Per surface whether is closed
-        boolList closed_;
-
         //- Per 'interface' surface : name of faceZone to put faces into
         wordList faceZoneNames_;
 
@@ -86,24 +90,12 @@ class refinementSurfaces
         //- From global region number to refinement level
         labelList maxLevel_;
 
-        //- From global region number to added layers
-        labelList numLayers_;
-
-        //- From global region number to patch name
-        wordList patchName_;
-
-        //- From global region number to patch name
-        wordList patchType_;
-
-
         //- 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&);
 
@@ -115,30 +107,36 @@ public:
 
     // Constructors
 
-        //- Construct from directory (io.instance()) and dictionaries
+        //- Construct from surfaces and dictionaries
         refinementSurfaces
         (
-            const IOobject& io,
+            const searchableSurfaces& allGeometry,
             const PtrList<dictionary>&
         );
 
+        //- Construct from surfaces and dictionary
+        refinementSurfaces
+        (
+            const searchableSurfaces& allGeometry,
+            const dictionary&
+        );
+
 
     // Member Functions
 
         // Access
 
+            const labelList& surfaces() const
+            {
+                return surfaces_;
+            }
+
             //- 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
             {
@@ -151,15 +149,11 @@ public:
                 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;
 
+            //- Get indices of closed named surfaces
+            labelList getClosedNamedSurfaces() const;
 
             //- From local region number to global region number
             const labelList& regionOffset() const
@@ -179,24 +173,6 @@ public:
                 return maxLevel_;
             }
 
-            //- From global region number to added layers
-            const labelList& numLayers() const
-            {
-                return numLayers_;
-            }
-
-            //- From global region number to patch name. Patchnames can be empty
-            const wordList& patchName() const
-            {
-                return patchName_;
-            }
-
-            //- From global region number to patch name
-            const wordList& patchType() const
-            {
-                return patchType_;
-            }
-
 
         // Helper
 
@@ -206,14 +182,6 @@ public:
                 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
             {
@@ -231,23 +199,12 @@ public:
                 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
+                const shellSurfaces& shells
             );
 
-            //- Helper: is surface closed?
-            static bool isSurfaceClosed(const triSurface&);
-
             //- Helper: orient (closed only) surfaces so keepPoint is outside.
             static void orientSurface
             (
@@ -263,36 +220,71 @@ public:
 
             //- Find intersection of edge. Return -1 or first surface
             //  with higher (than currentLevel) minlevel.
-            //  Return surface number and hit info.
-            label findHigherIntersection
+            //  Return surface number and level.
+            void findHigherIntersection
             (
-                const point& start,
-                const point& end,
-                const label currentLevel,   // current cell refinement level
-                pointIndexHit&
+                const pointField& start,
+                const pointField& end,
+                const labelList& currentLevel,  // current cell refinement level
+
+                labelList& surfaces,
+                labelList& surfaceLevel
             ) const;
 
-            //- Find intersection with max level. Return -1 or the surface
-            //  with the highest maxLevel above currentLevel
-            label findHighestIntersection
+            //- Find all intersections of edge. Unsorted order.
+            void findAllHigherIntersections
             (
-                const point& start,
-                const point& end,
-                const label currentLevel,   // current cell refinement level
-                pointIndexHit&
+                const pointField& start,
+                const pointField& end,
+                const labelList& currentLevel,  // current cell refinement level
+
+                List<vectorList>& surfaceNormal,
+                labelListList& surfaceLevel
             ) 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;
+            //- Find intersection nearest to the endpoints. surface1,2 are
+            //  not indices into surfacesToTest but refinement surface indices.
+            void findNearestIntersection
+            (
+                const labelList& surfacesToTest,
+                const pointField& start,
+                const pointField& end,
 
+                labelList& surface1,
+                List<pointIndexHit>& hit1,
+                labelList& region1,
+                labelList& surface2,
+                List<pointIndexHit>& hit2,
+                labelList& region2
+            ) 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;
+            //- Used for debugging only: find intersection of edge.
+            void findAnyIntersection
+            (
+                const pointField& start,
+                const pointField& end,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            ) const;
 
+            //- Find nearest point on surfaces.
+            void findNearest
+            (
+                const labelList& surfacesToTest,
+                const pointField& samples,
+                const scalarField& nearestDistSqr,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            ) const;
+
+            //- Detect if a point is 'inside' (closed) surfaces.
+            //  Returns -1 if not, returns first surface it is.
+            void findInside
+            (
+                const labelList& surfacesToTest,
+                const pointField& pt,
+                labelList& insideSurfaces
+            ) const;
 };
 
 
diff --git a/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.C b/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.C
new file mode 100644
index 0000000000..fe64ea81c3
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.C
@@ -0,0 +1,465 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "searchableSurface.H"
+#include "shellSurfaces.H"
+#include "boundBox.H"
+#include "triSurfaceMesh.H"
+#include "refinementSurfaces.H"
+#include "searchableSurfaces.H"
+#include "pointIndexHit.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+namespace Foam
+{
+
+template<>
+const char*
+NamedEnum<shellSurfaces::refineMode, 3>::
+names[] =
+{
+    "inside",
+    "outside",
+    "distance"
+};
+
+const NamedEnum<shellSurfaces::refineMode, 3> shellSurfaces::refineModeNames_;
+
+} // End namespace Foam
+
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::shellSurfaces::setAndCheckLevels
+(
+    const scalar shellI,
+    const List<Tuple2<scalar, label> >& distLevels
+)
+{
+    if (modes_[shellI] != DISTANCE && distLevels.size() != 1)
+    {
+        FatalErrorIn
+        (
+            "shellSurfaces::shellSurfaces"
+            "(const searchableSurfaces&, const dictionary&)"
+        )   << "For refinement mode "
+            << refineModeNames_[modes_[shellI]]
+            << " specify only one distance+level."
+            << " (its distance gets discarded)"
+            << exit(FatalError);
+    }
+    // Extract information into separate distance and level
+    distances_[shellI].setSize(distLevels.size());
+    levels_[shellI].setSize(distLevels.size());
+
+    forAll(distLevels, j)
+    {
+        distances_[shellI][j] = distLevels[j].first();
+        levels_[shellI][j] = distLevels[j].second();
+
+        // Check in incremental order
+        if (j > 0)
+        {
+            if
+            (
+                (distances_[shellI][j] <= distances_[shellI][j-1])
+             || (levels_[shellI][j] > levels_[shellI][j-1])
+            )
+            {
+                FatalErrorIn
+                (
+                    "shellSurfaces::shellSurfaces"
+                    "(const searchableSurfaces&, const dictionary&)"
+                )   << "For refinement mode "
+                    << refineModeNames_[modes_[shellI]]
+                    << " : Refinement should be specified in order"
+                    << " of increasing distance"
+                    << " (and decreasing refinement level)." << endl
+                    << "Distance:" << distances_[shellI][j]
+                    << " refinementLevel:" << levels_[shellI][j]
+                    << exit(FatalError);
+            }
+        }
+    }
+
+    const searchableSurface& shell = allGeometry_[shells_[shellI]];
+
+    if (modes_[shellI] == DISTANCE)
+    {
+        Info<< "Refinement level according to distance to "
+            << shell.name() << endl;
+        forAll(levels_[shellI], j)
+        {
+            Info<< "    level " << levels_[shellI][j]
+                << " for all cells within " << distances_[shellI][j]
+                << " meter." << endl;
+        }
+    }
+    else
+    {
+        if (!allGeometry_[shells_[shellI]].hasVolumeType())
+        {
+            FatalErrorIn
+            (
+                "shellSurfaces::shellSurfaces"
+                "(const searchableSurfaces&"
+                ", const PtrList<dictionary>&)"
+            )   << "Shell " << shell.name()
+                << " does not support testing for "
+                << refineModeNames_[modes_[shellI]] << endl
+                << "Probably it is not closed."
+                << exit(FatalError);
+        }
+
+        if (modes_[shellI] == INSIDE)
+        {
+            Info<< "Refinement level " << levels_[shellI][0]
+                << " for all cells inside " << shell.name() << endl;
+        }
+        else
+        {
+            Info<< "Refinement level " << levels_[shellI][0]
+                << " for all cells outside " << shell.name() << endl;
+        }
+    }
+}
+
+
+// Specifically orient triSurfaces using a calculated point outside.
+// Done since quite often triSurfaces not of consistent orientation which
+// is (currently) necessary for sideness calculation
+void Foam::shellSurfaces::orient()
+{
+    // Determine outside point.
+    boundBox overallBb
+    (
+        point(GREAT, GREAT, GREAT),
+        point(-GREAT, -GREAT, -GREAT)
+    );
+
+    bool hasSurface = false;
+
+    forAll(shells_, shellI)
+    {
+        const searchableSurface& s = allGeometry_[shells_[shellI]];
+
+        if (modes_[shellI] != DISTANCE && isA<triSurfaceMesh>(s))
+        {
+            const triSurfaceMesh& shell = refCast<const triSurfaceMesh>(s);
+
+            if (shell.triSurface::size() > 0)
+            {
+                const pointField& points = shell.points();
+
+                hasSurface = true;
+
+                boundBox shellBb(points[0], points[0]);
+                // Assume surface is compact!
+                for (label i = 0; i < points.size(); i++)
+                {
+                    const point& pt = points[i];
+                    shellBb.min() = min(shellBb.min(), pt);
+                    shellBb.max() = max(shellBb.max(), pt);
+                }
+
+                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)
+        {
+            const searchableSurface& s = allGeometry_[shells_[shellI]];
+
+            if (modes_[shellI] != DISTANCE && isA<triSurfaceMesh>(s))
+            {
+                triSurfaceMesh& shell = const_cast<triSurfaceMesh&>
+                (
+                    refCast<const triSurfaceMesh>(s)
+                );
+
+                refinementSurfaces::orientSurface(outsidePt, shell);
+            }
+        }
+    }
+}
+
+
+// Find maximum level of a shell.
+void Foam::shellSurfaces::findHigherLevel
+(
+    const pointField& pt,
+    const label shellI,
+    labelList& maxLevel
+) const
+{
+    const labelList& levels = levels_[shellI];
+
+    if (modes_[shellI] == DISTANCE)
+    {
+        // Distance mode.
+
+        const scalarField& distances = distances_[shellI];
+
+        // Collect all those points that have a current maxLevel less than
+        // (any of) the shell. Also collect the furthest distance allowable
+        // to any shell with a higher level.
+
+        pointField candidates(pt.size());
+        labelList candidateMap(pt.size());
+        scalarField candidateDistSqr(pt.size());
+        label candidateI = 0;
+
+        forAll(maxLevel, pointI)
+        {
+            forAllReverse(levels, levelI)
+            {
+                if (levels[levelI] > maxLevel[pointI])
+                {
+                    candidates[candidateI] = pt[pointI];
+                    candidateMap[candidateI] = pointI;
+                    candidateDistSqr[candidateI] = sqr(distances[levelI]);
+                    candidateI++;
+                    break;
+                }
+            }
+        }
+        candidates.setSize(candidateI);
+        candidateMap.setSize(candidateI);
+        candidateDistSqr.setSize(candidateI);
+
+        // Do the expensive nearest test only for the candidate points.
+        List<pointIndexHit> nearInfo;
+        allGeometry_[shells_[shellI]].findNearest
+        (
+            candidates,
+            candidateDistSqr,
+            nearInfo
+        );
+
+        // Update maxLevel
+        forAll(nearInfo, candidateI)
+        {
+            if (nearInfo[candidateI].hit())
+            {
+                // Check which level it actually is in.
+                label minDistI = findLower
+                (
+                    distances,
+                    mag(nearInfo[candidateI].hitPoint()-candidates[candidateI])
+                );
+
+                label pointI = candidateMap[candidateI];
+
+                // pt is inbetween shell[minDistI] and shell[minDistI+1]
+                maxLevel[pointI] = levels[minDistI+1];
+            }
+        }
+    }
+    else
+    {
+        // Inside/outside mode
+
+        // Collect all those points that have a current maxLevel less than the
+        // shell.
+
+        pointField candidates(pt.size());
+        labelList candidateMap(pt.size());
+        label candidateI = 0;
+
+        forAll(maxLevel, pointI)
+        {
+            if (levels[0] > maxLevel[pointI])
+            {
+                candidates[candidateI] = pt[pointI];
+                candidateMap[candidateI] = pointI;
+                candidateI++;
+            }
+        }
+        candidates.setSize(candidateI);
+        candidateMap.setSize(candidateI);
+
+        // Do the expensive nearest test only for the candidate points.
+        List<searchableSurface::volumeType> volType;
+        allGeometry_[shells_[shellI]].getVolumeType(candidates, volType);
+
+        forAll(volType, i)
+        {
+            label pointI = candidateMap[i];
+
+            if
+            (
+                (
+                    modes_[shellI] == INSIDE
+                 && volType[i] == searchableSurface::INSIDE
+                )
+             || (
+                    modes_[shellI] == OUTSIDE
+                 && volType[i] == searchableSurface::OUTSIDE
+                )
+            )
+            {
+                maxLevel[pointI] = levels[0];
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::shellSurfaces::shellSurfaces
+(
+    const searchableSurfaces& allGeometry,
+    const PtrList<dictionary>& shellDicts
+)
+:
+    allGeometry_(allGeometry)
+{
+    shells_.setSize(shellDicts.size());
+    modes_.setSize(shellDicts.size());
+    distances_.setSize(shellDicts.size());
+    levels_.setSize(shellDicts.size());
+
+    forAll(shellDicts, shellI)
+    {
+        const dictionary& dict = shellDicts[shellI];
+        const word name = dict.lookup("name");
+        const word type = dict.lookup("type");
+
+        shells_[shellI] = allGeometry_.findSurfaceID(name);
+
+        if (shells_[shellI] == -1)
+        {
+            FatalErrorIn
+            (
+                "shellSurfaces::shellSurfaces"
+                "(const searchableSurfaces&, const PtrList<dictionary>&)"
+            )   << "No surface called " << name << endl
+                << "Valid surfaces are " << allGeometry_.names()
+                << exit(FatalError);
+        }
+
+        modes_[shellI] = refineModeNames_.read(dict.lookup("refineMode"));
+
+        // Read pairs of distance+level
+        setAndCheckLevels(shellI, dict.lookup("levels"));
+    }
+
+    // Orient shell surfaces before any searching is done. Note that this
+    // only needs to be done for inside or outside. Orienting surfaces
+    // constructs lots of addressing which we want to avoid.
+    orient();
+}
+
+
+Foam::shellSurfaces::shellSurfaces
+(
+    const searchableSurfaces& allGeometry,
+    const dictionary& shellsDict
+)
+:
+    allGeometry_(allGeometry)
+{
+    shells_.setSize(shellsDict.size());
+    modes_.setSize(shellsDict.size());
+    distances_.setSize(shellsDict.size());
+    levels_.setSize(shellsDict.size());
+
+    label shellI = 0;
+    forAllConstIter(dictionary, shellsDict, iter)
+    {
+        shells_[shellI] = allGeometry_.findSurfaceID(iter().keyword());
+
+        if (shells_[shellI] == -1)
+        {
+            FatalErrorIn
+            (
+                "shellSurfaces::shellSurfaces"
+                "(const searchableSurfaces&, const dictionary>&"
+            )   << "No surface called " << iter().keyword() << endl
+                << "Valid surfaces are " << allGeometry_.names()
+                << exit(FatalError);
+        }
+        const dictionary& dict = shellsDict.subDict(iter().keyword());
+
+        modes_[shellI] = refineModeNames_.read(dict.lookup("mode"));
+
+        // Read pairs of distance+level
+        setAndCheckLevels(shellI, dict.lookup("levels"));
+
+        shellI++;
+    }
+
+    // Orient shell surfaces before any searching is done. Note that this
+    // only needs to be done for inside or outside. Orienting surfaces
+    // constructs lots of addressing which we want to avoid.
+    orient();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Highest shell level
+Foam::label Foam::shellSurfaces::maxLevel() const
+{
+    label overallMax = 0;
+    forAll(levels_, shellI)
+    {
+        overallMax = max(overallMax, max(levels_[shellI]));
+    }
+    return overallMax;
+}
+
+
+void Foam::shellSurfaces::findHigherLevel
+(
+    const pointField& pt,
+    const labelList& ptLevel,
+    labelList& maxLevel
+) const
+{
+    // Maximum level of any shell. Start off with level of point.
+    maxLevel = ptLevel;
+
+    forAll(shells_, shellI)
+    {
+        findHigherLevel(pt, shellI, maxLevel);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.H b/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.H
new file mode 100644
index 0000000000..b996e98e89
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.H
@@ -0,0 +1,182 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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
+    shellSurfaces
+
+Description
+    Encapsulates queries for volume refinement ('refine all cells within
+    shell').
+
+SourceFiles
+    shellSurfaces.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef shellSurfaces_H
+#define shellSurfaces_H
+
+#include "searchableSurface.H"
+#include "Tuple2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class searchableSurfaces;
+
+/*---------------------------------------------------------------------------*\
+                           Class shellSurfaces Declaration
+\*---------------------------------------------------------------------------*/
+
+class shellSurfaces
+{
+public:
+
+    // Public data types
+
+        //- Volume refinement controls
+        enum refineMode
+        {
+            INSIDE,         // Refine all inside shell
+            OUTSIDE,        // ,,         outside
+            DISTANCE        // Refine based on distance to shell
+        };
+
+
+private:
+
+    // Private data
+
+        //- Reference to all geometry.
+        const searchableSurfaces& allGeometry_;
+
+        //- Indices of surfaces that are shells
+        labelList shells_;
+
+        //- Per shell whether to refine inside or outside
+        List<refineMode> modes_;
+
+        //- Per shell the list of ranges
+        List<scalarField> distances_;
+
+        //- Per shell per distance the refinement level
+        labelListList levels_;
+
+
+    // Private data
+
+        //- refineMode names
+        static const NamedEnum<refineMode, 3> refineModeNames_;
+
+
+    // Private Member Functions
+
+        //- Helper function for initialisation.
+        void setAndCheckLevels
+        (
+            const scalar shellI,
+            const List<Tuple2<scalar, label> >&
+        );
+
+        void orient();
+
+        void findHigherLevel
+        (
+            const pointField& pt,
+            const label shellI,
+            labelList& maxLevel
+        ) const;
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        shellSurfaces
+        (
+            const searchableSurfaces& allGeometry,
+            const labelList& shells,
+            const List<refineMode>& modes,
+            const List<scalarField>& distances,
+            const labelListList& levels
+        );
+
+        //- Construct from geometry and dictionaries
+        shellSurfaces
+        (
+            const searchableSurfaces& allGeometry,
+            const PtrList<dictionary>& shellDicts
+        );
+
+        //- Construct from geometry and dictionary
+        shellSurfaces
+        (
+            const searchableSurfaces& allGeometry,
+            const dictionary& shellsDict
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            //const List<scalarField>& distances() const
+            //{
+            //    return distances_;
+            //}
+            //
+            ////- Per shell per distance the refinement level
+            //const labelListList& levels() const
+            //{
+            //    return levels_;
+            //}
+
+
+        // Query
+
+            //- Highest shell level
+            label maxLevel() const;
+
+            //- Find shell level higher than ptLevel
+            void findHigherLevel
+            (
+                const pointField& pt,
+                const labelList& ptLevel,
+                labelList& maxLevel
+            ) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
index 508143aaf9..cebb6597c2 100644
--- a/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
+++ b/src/autoMesh/autoHexMesh/trackedParticle/ExactParticle.C
@@ -256,7 +256,7 @@ Foam::Ostream& Foam::operator<<
     const ExactParticle<ParticleType>& p
 )
 {
-    return operator<<(os, static_cast<Particle<ParticleType> >(p));
+    return operator<<(os, static_cast<const Particle<ParticleType>&>(p));
 }
 
 
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
index c1c0e4f316..0742fd44b5 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.C
@@ -553,7 +553,7 @@ Foam::labelListList Foam::addPatchCellLayer::addedCells() const
 
 void Foam::addPatchCellLayer::setRefinement
 (
-    const scalar expansionRatio,
+    const scalarField& expansionRatio,
     const indirectPrimitivePatch& pp,
     const labelList& nFaceLayers,
     const labelList& nPointLayers,
@@ -885,7 +885,7 @@ void Foam::addPatchCellLayer::setRefinement
 
                 addedPoints_[patchPointI][i] = addedVertI;
 
-                disp *= expansionRatio;
+                disp *= expansionRatio[patchPointI];
             }
         }
     }
diff --git a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.H b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.H
index 0e47acb7ea..0b5caaba86 100644
--- a/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.H
+++ b/src/dynamicMesh/polyTopoChange/polyTopoChange/addPatchCellLayer.H
@@ -305,7 +305,7 @@ public:
             //        (instead of e.g. from patch faces)
            void setRefinement
            (
-               const scalar expansionRatio,
+               const scalarField& expansionRatio,
                const indirectPrimitivePatch& pp,
                const labelList& nFaceLayers,
                const labelList& nPointLayers,
@@ -325,7 +325,7 @@ public:
             {
                 setRefinement
                 (
-                    1.0,            // expansion ration
+                    scalarField(pp.nPoints(), 1.0), // expansion ration
                     pp,
                     labelList(pp.size(), nLayers),
                     labelList(pp.nPoints(), nLayers),
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 3a3d2aff83..90f9de250e 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -53,6 +53,14 @@ indexedOctree/treeDataFace.C
 indexedOctree/treeDataPoint.C
 indexedOctree/treeDataTriSurface.C
 
+searchableSurface = searchableSurface
+$(searchableSurface)/searchableBox.C
+$(searchableSurface)/searchableSphere.C
+$(searchableSurface)/searchableSurface.C
+$(searchableSurface)/searchableSurfaces.C
+$(searchableSurface)/searchableSurfacesQueries.C
+$(searchableSurface)/triSurfaceMesh.C
+
 topoSets = sets/topoSets
 $(topoSets)/cellSet.C
 $(topoSets)/topoSet.C
@@ -117,20 +125,10 @@ $(intersectedSurface)/intersectedSurface.C
 $(intersectedSurface)/edgeSurface.C
 
 triSurface/triSurfaceSearch/triSurfaceSearch.C
-
 triSurface/octreeData/octreeDataTriSurface.C
 triSurface/octreeData/octreeDataTriSurfaceTreeLeaf.C
-
 triSurface/triangleFuncs/triangleFuncs.C
-
-triSurface/searchableSurface/searchableSurface.C
-triSurface/searchableSurface/triSurfaceMesh.C
-triSurface/searchableSurface/searchableBox.C
-
 triSurface/surfaceFeatures/surfaceFeatures.C
-
-triSurface/triSurfaceMeshes/triSurfaceMeshes.C
-
 triSurface/triSurfaceTools/triSurfaceTools.C
 triSurface/triSurfaceTools/geompack/geompack.C
 
diff --git a/src/meshTools/searchableSurface/searchableBox.C b/src/meshTools/searchableSurface/searchableBox.C
new file mode 100644
index 0000000000..be3969d6f4
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableBox.C
@@ -0,0 +1,541 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "searchableBox.H"
+#include "addToRunTimeSelectionTable.H"
+#include "SortableList.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableBox, 0);
+addToRunTimeSelectionTable(searchableSurface, searchableBox, dict);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::searchableBox::projectOntoCoordPlane
+(
+    const direction dir,
+    const point& planePt,
+    pointIndexHit& info
+) const
+{
+    // Set point
+    info.rawPoint()[dir] = planePt[dir];
+    // Set face
+    if (planePt[dir] == min()[dir])
+    {
+        info.setIndex(dir*2);
+    }
+    else if (planePt[dir] == max()[dir])
+    {
+        info.setIndex(dir*2+1);
+    }
+    else
+    {
+        FatalErrorIn("searchableBox::projectOntoCoordPlane(..)")
+            << "Point on plane " << planePt
+            << " is not on coordinate " << min()[dir]
+            << " nor " << max()[dir] << abort(FatalError);
+    }
+}
+
+
+// Returns miss or hit with face (0..5) and region(always 0)
+Foam::pointIndexHit Foam::searchableBox::findNearest
+(
+    const point& bbMid,
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    // Point can be inside or outside. For every component direction can be
+    // left of min, right of max or inbetween.
+    // - outside points: project first one x plane (either min().x()
+    // or max().x()), then onto y plane and finally z. You should be left
+    // with intersection point
+    // - inside point: find nearest side (compare to mid point). Project onto
+    //   that.
+
+    // The face is set to the last projected face.
+
+
+    // Outside point projected onto cube. Assume faces 0..5.
+    pointIndexHit info(true, sample, -1);
+    bool outside = false;
+
+    // (for internal points) per direction what nearest cube side is
+    point near;
+
+    for (direction dir = 0; dir < vector::nComponents; dir++)
+    {
+        if (info.rawPoint()[dir] < min()[dir])
+        {
+            projectOntoCoordPlane(dir, min(), info);
+            outside = true;
+        }
+        else if (info.rawPoint()[dir] > max()[dir])
+        {
+            projectOntoCoordPlane(dir, max(), info);
+            outside = true;
+        }
+        else if (info.rawPoint()[dir] > bbMid[dir])
+        {
+            near[dir] = max()[dir];
+        }
+        else
+        {
+            near[dir] = min()[dir];
+        }
+    }
+
+
+    // For outside points the info will be correct now. Handle inside points
+    // using the three near distances. Project onto the nearest plane.
+    if (!outside)
+    {
+        vector dist(cmptMag(info.rawPoint() - near));
+
+        if (dist.x() < dist.y())
+        {
+            if (dist.x() < dist.z())
+            {
+                // Project onto x plane
+                projectOntoCoordPlane(vector::X, near, info);
+            }
+            else
+            {
+                projectOntoCoordPlane(vector::Z, near, info);
+            }
+        }
+        else
+        {
+            if (dist.y() < dist.z())
+            {
+                projectOntoCoordPlane(vector::Y, near, info);
+            }
+            else
+            {
+                projectOntoCoordPlane(vector::Z, near, info);
+            }
+        }
+    }
+
+
+    // Check if outside. Optimisation: could do some checks on distance already
+    // on components above
+    if (magSqr(info.rawPoint() - sample) > nearestDistSqr)
+    {
+        info.setMiss();
+        info.setIndex(-1);
+    }
+
+    return info;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::searchableBox::searchableBox
+(
+    const IOobject& io,
+    const treeBoundBox& bb
+)
+:
+    searchableSurface(io),
+    treeBoundBox(bb)
+{}
+
+
+Foam::searchableBox::searchableBox
+(
+    const IOobject& io,
+    const dictionary& dict
+)
+:
+    searchableSurface(io),
+    treeBoundBox(dict.lookup("min"), dict.lookup("max"))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::searchableBox::~searchableBox()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::wordList& Foam::searchableBox::regions() const
+{
+    if (regions_.size() == 0)
+    {
+        regions_.setSize(1);
+        regions_[0] = "region0";
+    }
+    return regions_;
+}
+
+
+Foam::pointIndexHit Foam::searchableBox::findNearest
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    return findNearest(mid(), sample, nearestDistSqr);
+}
+
+
+Foam::pointIndexHit Foam::searchableBox::findNearestOnEdge
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    const point bbMid(mid());
+
+    // Outside point projected onto cube. Assume faces 0..5.
+    pointIndexHit info(true, sample, -1);
+    bool outside = false;
+
+    // (for internal points) per direction what nearest cube side is
+    point near;
+
+    for (direction dir = 0; dir < vector::nComponents; dir++)
+    {
+        if (info.rawPoint()[dir] < min()[dir])
+        {
+            projectOntoCoordPlane(dir, min(), info);
+            outside = true;
+        }
+        else if (info.rawPoint()[dir] > max()[dir])
+        {
+            projectOntoCoordPlane(dir, max(), info);
+            outside = true;
+        }
+        else if (info.rawPoint()[dir] > bbMid[dir])
+        {
+            near[dir] = max()[dir];
+        }
+        else
+        {
+            near[dir] = min()[dir];
+        }
+    }
+
+
+    // For outside points the info will be correct now. Handle inside points
+    // using the three near distances. Project onto the nearest two planes.
+    if (!outside)
+    {
+        // Get the per-component distance to nearest wall
+        vector dist(cmptMag(info.rawPoint() - near));
+
+        SortableList<scalar> sortedDist(3);
+        sortedDist[0] = dist[0];
+        sortedDist[1] = dist[1];
+        sortedDist[2] = dist[2];
+        sortedDist.sort();
+
+        // Project onto nearest
+        projectOntoCoordPlane(sortedDist.indices()[0], near, info);
+        // Project onto second nearest
+        projectOntoCoordPlane(sortedDist.indices()[1], near, info);
+    }
+
+
+    // Check if outside. Optimisation: could do some checks on distance already
+    // on components above
+    if (magSqr(info.rawPoint() - sample) > nearestDistSqr)
+    {
+        info.setMiss();
+        info.setIndex(-1);
+    }
+
+    return info;
+}
+
+
+Foam::pointIndexHit Foam::searchableBox::findNearest
+(
+    const linePointRef& ln,
+    treeBoundBox& tightest,
+    point& linePoint
+) const
+{
+    notImplemented
+    (
+        "searchableBox::findNearest"
+        "(const linePointRef&, treeBoundBox&, point&)"
+    );
+    return pointIndexHit();
+}
+
+
+Foam::pointIndexHit Foam::searchableBox::findLine
+(
+    const point& start,
+    const point& end
+) const
+{
+    pointIndexHit info(false, start, -1);
+
+    bool foundInter;
+
+    if (posBits(start) == 0)
+    {
+        if (posBits(end) == 0)
+        {
+            // Both start and end inside.
+            foundInter = false;
+        }
+        else
+        {
+            // end is outside. Clip to bounding box.
+            foundInter = intersects(end, start, info.rawPoint());
+        }
+    }
+    else
+    {
+        // start is outside. Clip to bounding box.
+        foundInter = intersects(start, end, info.rawPoint());
+    }
+
+
+    // Classify point
+    if (foundInter)
+    {
+        info.setHit();
+
+        for (direction dir = 0; dir < vector::nComponents; dir++)
+        {
+            if (info.rawPoint()[dir] == min()[dir])
+            {
+                info.setIndex(2*dir);
+                break;
+            }
+            else if (info.rawPoint()[dir] == max()[dir])
+            {
+                info.setIndex(2*dir+1);
+                break;
+            }
+        }
+
+        if (info.index() == -1)
+        {
+            FatalErrorIn("searchableBox::findLine(const point&, const point&)")
+                << "point " << info.rawPoint()
+                << " on segment " << start << end
+                << " should be on face of " << *this
+                << " but it isn't." << abort(FatalError);
+        }
+    }
+
+    return info;
+}
+
+
+Foam::pointIndexHit Foam::searchableBox::findLineAny
+(
+    const point& start,
+    const point& end
+) const
+{
+    return findLine(start, end);
+}
+
+
+void Foam::searchableBox::findNearest
+(
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(samples.size());
+
+    const point bbMid(mid());
+
+    forAll(samples, i)
+    {
+        info[i] = findNearest(bbMid, samples[i], nearestDistSqr[i]);
+    }
+}
+
+
+void Foam::searchableBox::findLine
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        info[i] = findLine(start[i], end[i]);
+    }
+}
+
+
+void Foam::searchableBox::findLineAny
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        info[i] = findLineAny(start[i], end[i]);
+    }
+}
+
+
+void Foam::searchableBox::findLineAll
+(
+    const pointField& start,
+    const pointField& end,
+    List<List<pointIndexHit> >& info
+) const
+{
+    info.setSize(start.size());
+
+    // Work array
+    DynamicList<pointIndexHit, 1, 1> hits;
+
+    // Tolerances
+    const vectorField dirVec(end-start);
+    const scalarField magSqrDirVec(magSqr(dirVec));
+    const vectorField smallVec
+    (
+        Foam::sqrt(SMALL)*dirVec
+      + vector(ROOTVSMALL,ROOTVSMALL,ROOTVSMALL)
+    );
+
+    forAll(start, pointI)
+    {
+        hits.clear();
+
+        // Current starting point of ray.
+        point pt = start[pointI];
+
+        while (true)
+        {
+            // See if any intersection between pt and end
+            pointIndexHit inter = findLine(pt, end[pointI]);
+
+            if (!inter.hit())
+            {
+                break;
+            }
+            hits.append(inter);
+
+            pt = inter.hitPoint() + smallVec[pointI];
+
+            if (((pt-start[pointI])&dirVec[pointI]) > magSqrDirVec[pointI])
+            {
+                // Adding smallVec has taken us beyond end
+                break;
+            }
+        }
+
+        hits.shrink();
+        info[pointI].transfer(hits);
+        hits.clear();
+    }
+}
+
+
+void Foam::searchableBox::getRegion
+(
+    const List<pointIndexHit>& info,
+    labelList& region
+) const
+{
+    region.setSize(info.size());
+    region = 0;
+}
+
+
+void Foam::searchableBox::getNormal
+(
+    const List<pointIndexHit>& info,
+    vectorField& normal
+) const
+{
+    normal.setSize(info.size());
+    normal = vector::zero;
+
+    forAll(info, i)
+    {
+        if (info[i].hit())
+        {
+            normal[i] = treeBoundBox::faceNormals[info[i].index()];
+        }
+        else
+        {
+            // Set to what?
+        }
+    }
+}
+
+
+void Foam::searchableBox::getVolumeType
+(
+    const pointField& points,
+    List<volumeType>& volType
+) const
+{
+    volType.setSize(points.size());
+    volType = INSIDE;
+
+    forAll(points, pointI)
+    {
+        const point& pt = points[pointI];
+
+        for (direction dir = 0; dir < vector::nComponents; dir++)
+        {
+            if (pt[dir] < min()[dir] || pt[dir] > max()[dir])
+            {
+                volType[pointI] = OUTSIDE;
+                break;
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableBox.H b/src/meshTools/searchableSurface/searchableBox.H
new file mode 100644
index 0000000000..f606f83e1e
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableBox.H
@@ -0,0 +1,249 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    Foam::searchableBox
+
+Description
+    Searching on bounding box
+
+SourceFiles
+    searchableBox.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableBox_H
+#define searchableBox_H
+
+#include "searchableSurface.H"
+#include "treeBoundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableBox Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableBox
+:
+    public searchableSurface,
+    public treeBoundBox
+{
+private:
+
+    // Private Member Data
+
+        mutable wordList regions_;
+
+
+    // Private Member Functions
+
+        //- Project onto component dir of planePt and update index() (=face)
+        void projectOntoCoordPlane
+        (
+            const direction dir,
+            const point& planePt,
+            pointIndexHit& info
+        ) const;
+
+        //- Returns miss or hit with face (0..5)
+        pointIndexHit findNearest
+        (
+            const point& bbMid,
+            const point& sample,
+            const scalar nearestDistSqr
+        ) const;
+
+
+        //- Disallow default bitwise copy construct
+        searchableBox(const searchableBox&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableBox&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableBox");
+
+
+    // Constructors
+
+        //- Construct from components
+        searchableBox(const IOobject& io, const treeBoundBox& bb);
+
+        //- Construct from dictionary (used by searchableSurface)
+        searchableBox
+        (
+            const IOobject& io,
+            const dictionary& dict
+        );
+
+    // Destructor
+
+        virtual ~searchableBox();
+
+
+    // Member Functions
+
+        virtual const wordList& regions() const;
+
+        //- Whether supports volume type below
+        virtual bool hasVolumeType() const
+        {
+            return true;
+        }
+
+
+        // Single point queries.
+
+            //- Calculate nearest point on surface. Returns
+            //  - bool : any point found nearer than nearestDistSqr
+            //  - label: relevant index in surface (=face 0..5)
+            //  - point: actual nearest point found
+            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
+            pointIndexHit findNearestOnEdge
+            (
+                const point& sample,
+                const scalar nearestDistSqr
+            ) const;
+
+            //- Find nearest to segment. Returns
+            //  - bool : any point found?
+            //  - label: relevant index in shapes (=face 0..5)
+            //  - point: actual nearest point found
+            //  sets:
+            //  - tightest  : bounding box
+            //  - linePoint : corresponding nearest point on line
+            pointIndexHit findNearest
+            (
+                const linePointRef& ln,
+                treeBoundBox& tightest,
+                point& linePoint
+            ) const;
+
+            //- Find nearest intersection of line between start and end.
+            pointIndexHit findLine
+            (
+                const point& start,
+                const point& end
+            ) const;
+
+            //- Find any intersection of line between start and end.
+            pointIndexHit findLineAny
+            (
+                const point& start,
+                const point& end
+            ) const;
+
+
+        // Multiple point queries.
+
+            virtual void findNearest
+            (
+                const pointField& sample,
+                const scalarField& nearestDistSqr,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLine
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLineAny
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            //- Get all intersections in order from start to end.
+            virtual void findLineAll
+            (
+                const pointField& start,
+                const pointField& end,
+                List<List<pointIndexHit> >&
+            ) const;
+
+            //- From a set of points and indices get the region
+            virtual void getRegion
+            (
+                const List<pointIndexHit>&,
+                labelList& region
+            ) const;
+
+            //- From a set of points and indices get the normal
+            virtual void getNormal
+            (
+                const List<pointIndexHit>&,
+                vectorField& normal
+            ) const;
+
+            //- Determine type (inside/outside/mixed) for point. unknown if
+            //  cannot be determined (e.g. non-manifold surface)
+            virtual void getVolumeType
+            (
+                const pointField&,
+                List<volumeType>&
+            ) const;
+
+
+        // regIOobject implementation
+
+            bool writeData(Ostream&) const
+            {
+                notImplemented("searchableBox::writeData(Ostream&) const");
+                return false;
+            }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSphere.C b/src/meshTools/searchableSurface/searchableSphere.C
new file mode 100644
index 0000000000..eb16e27318
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSphere.C
@@ -0,0 +1,328 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "searchableSphere.H"
+#include "addToRunTimeSelectionTable.H"
+#include "SortableList.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableSphere, 0);
+addToRunTimeSelectionTable(searchableSurface, searchableSphere, dict);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::pointIndexHit Foam::searchableSphere::findNearest
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    pointIndexHit info(false, sample, -1);
+
+    const vector n(sample-centre_);
+    scalar magN = mag(n);
+
+    if (nearestDistSqr > sqr(magN-radius_))
+    {
+        info.rawPoint() = centre_ + n/magN*radius_;
+        info.setHit();
+        info.setIndex(0);
+    }
+
+    return info;
+}
+
+
+// From Graphics Gems - intersection of sphere with ray
+void Foam::searchableSphere::findLineAll
+(
+    const point& start,
+    const point& end,
+    pointIndexHit& near,
+    pointIndexHit& far
+) const
+{
+    near.setMiss();
+    far.setMiss();
+
+    vector dir(end-start);
+    scalar magSqrDir = magSqr(dir);
+
+    if (magSqrDir > ROOTVSMALL)
+    {
+        const vector toCentre(centre_-start);
+        scalar magSqrToCentre = magSqr(toCentre);
+
+        dir /= Foam::sqrt(magSqrDir);
+
+        scalar v = (toCentre & dir);
+
+        scalar disc = sqr(radius_) - (magSqrToCentre - sqr(v));
+
+        if (disc >= 0)
+        {
+            scalar d = Foam::sqrt(disc);
+
+            scalar nearParam = v-d;
+
+            if (nearParam >= 0 && sqr(nearParam) <= magSqrDir)
+            {
+                near.setHit();
+                near.setPoint(start + nearParam*dir);
+                near.setIndex(0);
+            }
+
+            scalar farParam = v+d;
+
+            if (farParam >= 0 && sqr(farParam) <= magSqrDir)
+            {
+                far.setHit();
+                far.setPoint(start + farParam*dir);
+                far.setIndex(0);
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::searchableSphere::searchableSphere
+(
+    const IOobject& io,
+    const point& centre,
+    const scalar radius
+)
+:
+    searchableSurface(io),
+    centre_(centre),
+    radius_(radius)
+{}
+
+
+Foam::searchableSphere::searchableSphere
+(
+    const IOobject& io,
+    const dictionary& dict
+)
+:
+    searchableSurface(io),
+    centre_(dict.lookup("centre")),
+    radius_(readScalar(dict.lookup("radius")))
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::searchableSphere::~searchableSphere()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::wordList& Foam::searchableSphere::regions() const
+{
+    if (regions_.size() == 0)
+    {
+        regions_.setSize(1);
+        regions_[0] = "region0";
+    }
+    return regions_;
+}
+
+
+
+void Foam::searchableSphere::findNearest
+(
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(samples.size());
+
+    forAll(samples, i)
+    {
+        info[i] = findNearest(samples[i], nearestDistSqr[i]);
+    }
+}
+
+
+void Foam::searchableSphere::findLine
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(start.size());
+
+    pointIndexHit b;
+
+    forAll(start, i)
+    {
+        // Pick nearest intersection. If none intersected take second one.
+        findLineAll(start[i], end[i], info[i], b);
+        if (!info[i].hit() && b.hit())
+        {
+            info[i] = b;
+        }
+    }
+}
+
+
+void Foam::searchableSphere::findLineAny
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(start.size());
+
+    pointIndexHit b;
+
+    forAll(start, i)
+    {
+        // Discard far intersection
+        findLineAll(start[i], end[i], info[i], b);
+        if (!info[i].hit() && b.hit())
+        {
+            info[i] = b;
+        }
+    }
+}
+
+
+void Foam::searchableSphere::findLineAll
+(
+    const pointField& start,
+    const pointField& end,
+    List<List<pointIndexHit> >& info
+) const
+{
+    info.setSize(start.size());
+
+    pointIndexHit near, far;
+
+    forAll(start, i)
+    {
+        findLineAll(start[i], end[i], near, far);
+
+        if (near.hit())
+        {
+            if (far.hit())
+            {
+                info[i].setSize(2);
+                info[i][0] = near;
+                info[i][1] = far;
+            }
+            else
+            {
+                info[i].setSize(1);
+                info[i][0] = near;
+            }
+        }
+        else
+        {
+            if (far.hit())
+            {
+                info[i].setSize(1);
+                info[i][0] = far;
+            }
+        }
+    }
+}
+
+
+void Foam::searchableSphere::getRegion
+(
+    const List<pointIndexHit>& info,
+    labelList& region
+) const
+{
+    region.setSize(info.size());
+    region = 0;
+}
+
+
+void Foam::searchableSphere::getNormal
+(
+    const List<pointIndexHit>& info,
+    vectorField& normal
+) const
+{
+    normal.setSize(info.size());
+    normal = vector::zero;
+
+    forAll(info, i)
+    {
+        if (info[i].hit())
+        {
+            normal[i] = info[i].hitPoint() - centre_;
+            normal[i] /= mag(normal[i]);
+        }
+        else
+        {
+            // Set to what?
+        }
+    }
+}
+
+
+void Foam::searchableSphere::getVolumeType
+(
+    const pointField& points,
+    List<volumeType>& volType
+) const
+{
+    volType.setSize(points.size());
+    volType = INSIDE;
+
+    forAll(points, pointI)
+    {
+        const point& pt = points[pointI];
+
+        if (magSqr(pt - centre_) <= sqr(radius_))
+        {
+            volType[pointI] = INSIDE;
+        }
+        else
+        {
+            volType[pointI] = OUTSIDE;
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSphere.H b/src/meshTools/searchableSurface/searchableSphere.H
new file mode 100644
index 0000000000..7b3f4856ac
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSphere.H
@@ -0,0 +1,204 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    Foam::searchableSphere
+
+Description
+    Searching on sphere
+
+SourceFiles
+    searchableSphere.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSphere_H
+#define searchableSphere_H
+
+#include "searchableSurface.H"
+#include "treeBoundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableSphere Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSphere
+:
+    public searchableSurface
+{
+private:
+
+    // Private Member Data
+
+        //- Centre point
+        const point centre_;
+
+        //- Radius squared
+        const scalar radius_;
+
+        //- Names of regions
+        mutable wordList regions_;
+
+
+    // Private Member Functions
+
+        //- Find nearest point on sphere.
+        pointIndexHit findNearest
+        (
+            const point& sample,
+            const scalar nearestDistSqr
+        ) const;
+
+        //- Find intersection with sphere
+        void findLineAll
+        (
+            const point& start,
+            const point& end,
+            pointIndexHit& near,
+            pointIndexHit& far
+        ) const;
+
+
+        //- Disallow default bitwise copy construct
+        searchableSphere(const searchableSphere&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableSphere&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableSphere");
+
+
+    // Constructors
+
+        //- Construct from components
+        searchableSphere(const IOobject& io, const point&, const scalar radius);
+
+        //- Construct from dictionary (used by searchableSurface)
+        searchableSphere
+        (
+            const IOobject& io,
+            const dictionary& dict
+        );
+
+    // Destructor
+
+        virtual ~searchableSphere();
+
+
+    // Member Functions
+
+        virtual const wordList& regions() const;
+
+        //- Whether supports volume type below
+        virtual bool hasVolumeType() const
+        {
+            return true;
+        }
+
+
+        // Multiple point queries.
+
+            virtual void findNearest
+            (
+                const pointField& sample,
+                const scalarField& nearestDistSqr,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLine
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLineAny
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            //- Get all intersections in order from start to end.
+            virtual void findLineAll
+            (
+                const pointField& start,
+                const pointField& end,
+                List<List<pointIndexHit> >&
+            ) const;
+
+            //- From a set of points and indices get the region
+            virtual void getRegion
+            (
+                const List<pointIndexHit>&,
+                labelList& region
+            ) const;
+
+            //- From a set of points and indices get the normal
+            virtual void getNormal
+            (
+                const List<pointIndexHit>&,
+                vectorField& normal
+            ) const;
+
+            //- Determine type (inside/outside/mixed) for point. unknown if
+            //  cannot be determined (e.g. non-manifold surface)
+            virtual void getVolumeType
+            (
+                const pointField&,
+                List<volumeType>&
+            ) const;
+
+
+        // regIOobject implementation
+
+            bool writeData(Ostream&) const
+            {
+                notImplemented("searchableSphere::writeData(Ostream&) const");
+                return false;
+            }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/triSurface/searchableSurface/searchableSurface.C b/src/meshTools/searchableSurface/searchableSurface.C
similarity index 65%
rename from src/meshTools/triSurface/searchableSurface/searchableSurface.C
rename to src/meshTools/searchableSurface/searchableSurface.C
index 11996e7534..9e6cffa315 100644
--- a/src/meshTools/triSurface/searchableSurface/searchableSurface.C
+++ b/src/meshTools/searchableSurface/searchableSurface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,15 +34,13 @@ namespace Foam
 
 defineTypeNameAndDebug(searchableSurface, 0);
 defineRunTimeSelectionTable(searchableSurface, dict);
-//defineRunTimeSelectionTable(searchableSurface, istream);
 
 
 // Construct named object from dictionary
 autoPtr<searchableSurface> searchableSurface::New
 (
     const word& searchableSurfaceType,
-    const word& name,
-    const objectRegistry& obj,
+    const IOobject& io,
     const dictionary& dict
 )
 {
@@ -55,7 +53,7 @@ autoPtr<searchableSurface> searchableSurface::New
         FatalErrorIn
         (
             "searchableSurface::New(const word&, const word&"
-            ", const objectRegistry&, const dictionary&)"
+            ", const IOobject&, const dictionary&)"
         )   << "Unknown searchableSurface type " << searchableSurfaceType
             << endl << endl
             << "Valid searchableSurface types : " << endl
@@ -63,44 +61,15 @@ autoPtr<searchableSurface> searchableSurface::New
             << exit(FatalError);
     }
 
-    return autoPtr<searchableSurface>(cstrIter()(name, obj, dict));
+    return autoPtr<searchableSurface>(cstrIter()(io, dict));
 }
 
 
-//// Construct named object from Istream
-//autoPtr<searchableSurface> searchableSurface::New
-//(
-//    const word& searchableSurfaceType,
-//    const objectRegistry& obj,
-//    Istream& is
-//)
-//{
-//    istreamConstructorTable::iterator cstrIter =
-//        istreamConstructorTablePtr_
-//            ->find(searchableSurfaceType);
-//
-//    if (cstrIter == istreamConstructorTablePtr_->end())
-//    {
-//        FatalErrorIn
-//        (
-//            "searchableSurface::New(const word&, const objectRegistry&"
-//            ", Istream&)"
-//        )   << "Unknown searchableSurface type " << searchableSurfaceType
-//            << endl << endl
-//            << "Valid searchableSurface types : " << endl
-//            << istreamConstructorTablePtr_->toc()
-//            << exit(FatalError);
-//    }
-//
-//    return autoPtr<searchableSurface>(cstrIter()(obj, is));
-//}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::searchableSurface::searchableSurface(const word& name)
+Foam::searchableSurface::searchableSurface(const IOobject& io)
 :
-    name_(name)
+    regIOobject(io)
 {}
 
 
diff --git a/src/meshTools/searchableSurface/searchableSurface.H b/src/meshTools/searchableSurface/searchableSurface.H
new file mode 100644
index 0000000000..43e008ca50
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSurface.H
@@ -0,0 +1,322 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    Foam::searchableSurface
+
+Description
+    Base class of (analytical or triangulated) surface.
+    Encapsulates all the search routines. WIP.
+
+    Information returned is usually a pointIndexHit:
+    - bool  : was intersection/nearest found?
+    - point : intersection point or nearest point
+    - index : unique index on surface (e.g. triangle for triSurfaceMesh)
+
+SourceFiles
+    searchableSurface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSurface_H
+#define searchableSurface_H
+
+#include "pointField.H"
+#include "typeInfo.H"
+#include "runTimeSelectionTables.H"
+#include "pointIndexHit.H"
+#include "linePointRef.H"
+#include "objectRegistry.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class treeBoundBox;
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableSurface Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSurface
+:
+    public regIOobject
+{
+public:
+
+    // Data types
+
+        //- volume types
+        enum volumeType
+        {
+            UNKNOWN = 0,
+            MIXED = 1,      // not used. only here to maintain consistency with
+                            // indexedOctree volumeType.
+            INSIDE = 2,
+            OUTSIDE = 3
+        };
+
+private:
+
+    // Private data
+
+        const word name_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        searchableSurface(const searchableSurface&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableSurface&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableSurface");
+
+    // Declare run-time constructor selection table
+
+        // For the dictionary constructor
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            searchableSurface,
+            dict,
+            (
+                const IOobject& io,
+                const dictionary& dict
+            ),
+            (io, dict)
+        );
+
+
+        //- Class used for the read-construction of
+        //  PtrLists of searchableSurface.
+        class iNew
+        {
+            IOobject& io_;
+
+        public:
+
+            iNew(IOobject& io)
+            :
+                io_(io)
+            {}
+
+            autoPtr<searchableSurface> operator()(Istream& is) const
+            {
+                word surfaceType(is);
+                word readName(is);
+                dictionary dict(is);
+
+                autoPtr<IOobject> namedIO(io_.clone());
+                namedIO().rename(readName);
+                return searchableSurface::New(surfaceType, namedIO(), dict);
+            }
+        };
+
+
+    // Constructors
+
+        searchableSurface(const IOobject& io);
+
+        //- Clone
+        virtual autoPtr<searchableSurface> clone() const
+        {
+            notImplemented("autoPtr<searchableSurface> clone() const");
+            return autoPtr<searchableSurface>(NULL);
+        }
+
+
+    // Selectors
+
+        //- Return a reference to the selected searchableSurface
+        static autoPtr<searchableSurface> New
+        (
+            const word& surfaceType,
+            const IOobject& io,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~searchableSurface();
+
+
+    // Member Functions
+
+
+        //- Names of regions.
+        virtual const wordList& regions() const = 0;
+
+        //- Whether supports volume type below.
+        virtual bool hasVolumeType() const = 0;
+
+
+        // Single point queries.
+
+            ////- Calculate nearest point on surface. Returns
+            ////  - bool : any point found nearer than nearestDistSqr
+            ////  - label: relevant index in surface
+            ////  - label: region in surface
+            ////  - point: actual nearest point found
+            //virtual pointIndexHit findNearest
+            //(
+            //    const point& sample,
+            //    const scalar nearestDistSqr
+            //) const = 0;
+            //
+            ////- Calculate nearest point on edge. Returns
+            ////  - bool : any point found nearer than nearestDistSqr
+            ////  - label: relevant index in surface
+            ////  - label: region in surface
+            ////  - point: actual nearest point found
+            //virtual pointIndexHit findNearestOnEdge
+            //(
+            //    const point& sample,
+            //    const scalar nearestDistSqr
+            //) const = 0;
+            //
+            ////- Find nearest to segment. Returns
+            ////  - bool : any point found?
+            ////  - label: relevant index in shapes
+            ////  - label: region in surface
+            ////  - 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 = 0;
+            //
+            ////- Find nearest intersection of line between start and end.
+            //virtual pointIndexHit findLine
+            //(
+            //    const point& start,
+            //    const point& end
+            //) const = 0;
+            //
+            ////- Find any intersection of line between start and end.
+            //virtual pointIndexHit findLineAny
+            //(
+            //    const point& start,
+            //    const point& end
+            //) const = 0;
+
+
+        // Multiple point queries. When surface is distributed the index
+        // should be a global index. Not done yet.
+
+            virtual void findNearest
+            (
+                const pointField& sample,
+                const scalarField& nearestDistSqr,
+                List<pointIndexHit>&
+            ) const = 0;
+
+            //- Find first intersection on segment from start to end.
+            //  Note: searchableSurfacesQueries expects no
+            //  intersection to be found if start==end. Is problem?
+            virtual void findLine
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const = 0;
+
+            //- Return any intersection on segment from start to end.
+            virtual void findLineAny
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const = 0;
+
+            //- Get all intersections in order from start to end.
+            virtual void findLineAll
+            (
+                const pointField& start,
+                const pointField& end,
+                List<List<pointIndexHit> >&
+            ) const = 0;
+
+            //- From a set of points and indices get the region
+            virtual void getRegion
+            (
+                const List<pointIndexHit>&,
+                labelList& region
+            ) const = 0;
+
+            //- From a set of points and indices get the normal
+            virtual void getNormal
+            (
+                const List<pointIndexHit>&,
+                vectorField& normal
+            ) const = 0;
+
+            //- Determine type (inside/outside) for point. unknown if
+            //  cannot be determined (e.g. non-manifold surface)
+            virtual void getVolumeType
+            (
+                const pointField&,
+                List<volumeType>&
+            ) const = 0;
+
+
+        // Other
+
+            ////- Get bounding box.
+            //const boundBox& bounds() const = 0;
+
+            ////- Set bounding box.
+            //void setBounds
+            //(
+            //    const boundBox&,
+            //    autoPtr<mapDistribute>& faceMap,
+            //    autoPtr<mapDistribute>& pointMap
+            //) = 0;
+
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSurfaces.C b/src/meshTools/searchableSurface/searchableSurfaces.C
new file mode 100644
index 0000000000..8fbb4678e7
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSurfaces.C
@@ -0,0 +1,355 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "searchableSurfaces.H"
+#include "searchableSurfacesQueries.H"
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableSurfaces, 0);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct with length.
+Foam::searchableSurfaces::searchableSurfaces(const label size)
+:
+    PtrList<searchableSurface>(size),
+    regionNames_(size),
+    allSurfaces_(identity(size))
+{}
+
+
+//Foam::searchableSurfaces::searchableSurfaces
+//(
+//    const IOobject& io,
+//    const PtrList<dictionary>& dicts
+//)
+//:
+//    PtrList<searchableSurface>(dicts.size()),
+//    regionNames_(dicts.size()),
+//    allSurfaces_(identity(dicts.size()))
+//{
+//    forAll(dicts, surfI)
+//    {
+//        const dictionary& dict = dicts[surfI];
+//
+//        // Make IOobject with correct name
+//        autoPtr<IOobject> namedIO(io.clone());
+//        namedIO().rename(dict.lookup("name"));
+//
+//        // Create and hook surface
+//        set
+//        (
+//            surfI,
+//            searchableSurface::New
+//            (
+//                dict.lookup("type"),
+//                namedIO(),
+//                dict
+//            )
+//        );
+//        const searchableSurface& s = operator[](surfI);
+//
+//        // Construct default region names by prepending surface name
+//        // to region name.
+//        const wordList& localNames = s.regions();
+//
+//        wordList globalNames(localNames.size());
+//        forAll(localNames, regionI)
+//        {
+//            globalNames[regionI] = s.name() + '_' + localNames[regionI];
+//        }
+//
+//        // See if dictionary provides any global region names.
+//        if (dict.found("regions"))
+//        {
+//            const dictionary& regionsDict = dict.subDict("regions");
+//
+//            forAllConstIter(dictionary, regionsDict, iter)
+//            {
+//                const word& key = iter().keyword();
+//
+//                if (regionsDict.isDict(key))
+//                {
+//                    // Get the dictionary for region iter.key()
+//                    const dictionary& regionDict = regionsDict.subDict(key);
+//
+//                    label index = findIndex(localNames, key);
+//
+//                    if (index == -1)
+//                    {
+//                        FatalErrorIn
+//                        (
+//                            "searchableSurfaces::searchableSurfaces"
+//                            "( const IOobject&, const dictionary&)"
+//                        )   << "Unknown region name " << key
+//                            << " for surface " << s.name() << endl
+//                            << "Valid region names are " << localNames
+//                            << exit(FatalError);
+//                    }
+//
+//                    globalNames[index] = word(regionDict.lookup("name"));
+//                }
+//            }
+//        }
+//
+//        // Now globalNames contains the names of the regions.
+//        Info<< "Surface:" << s.name() << " has regions:"
+//            << endl;
+//        forAll(globalNames, regionI)
+//        {
+//            Info<< "    " << globalNames[regionI] << endl;
+//        }
+//
+//        // Create reverse lookup
+//        forAll(globalNames, regionI)
+//        {
+//            regionNames_.insert
+//            (
+//                globalNames[regionI],
+//                labelPair(surfI, regionI)
+//            );
+//        }
+//    }
+//}
+
+
+Foam::searchableSurfaces::searchableSurfaces
+(
+    const IOobject& io,
+    const dictionary& topDict
+)
+:
+    PtrList<searchableSurface>(topDict.size()),
+    names_(topDict.size()),
+    regionNames_(topDict.size()),
+    allSurfaces_(identity(topDict.size()))
+{
+    label surfI = 0;
+    forAllConstIter(dictionary, topDict, iter)
+    {
+        const word& key = iter().keyword();
+
+        if (!topDict.isDict(key))
+        {
+            FatalErrorIn
+            (
+                "searchableSurfaces::searchableSurfaces"
+                "( const IOobject&, const dictionary&)"
+            )   << "Found non-dictionary entry " << iter()
+                << " in top-level dictionary " << topDict
+                << exit(FatalError);
+        }
+
+        const dictionary& dict = topDict.subDict(key);
+
+        names_[surfI] = key;
+
+        if (dict.found("name"))
+        {
+            dict.lookup("name") >> names_[surfI];
+        }
+
+
+        // Make IOobject with correct name
+        autoPtr<IOobject> namedIO(io.clone());
+        // Note: we would like to e.g. register triSurface 'sphere.stl' as
+        // 'sphere'. Unfortunately
+        // no support for having object read from different location than
+        // their object name. Maybe have stlTriSurfaceMesh which appends .stl
+        // when reading/writing?
+        namedIO().rename(key);  // names_[surfI]
+
+        // Create and hook surface
+        set
+        (
+            surfI,
+            searchableSurface::New
+            (
+                dict.lookup("type"),
+                namedIO(),
+                dict
+            )
+        );
+        const searchableSurface& s = operator[](surfI);
+
+        // Construct default region names by prepending surface name
+        // to region name.
+        const wordList& localNames = s.regions();
+
+        wordList& rNames = regionNames_[surfI];
+        rNames.setSize(localNames.size());
+
+        forAll(localNames, regionI)
+        {
+            rNames[regionI] = names_[surfI] + '_' + localNames[regionI];
+        }
+
+        // See if dictionary provides any global region names.
+        if (dict.found("regions"))
+        {
+            const dictionary& regionsDict = dict.subDict("regions");
+
+            forAllConstIter(dictionary, regionsDict, iter)
+            {
+                const word& key = iter().keyword();
+
+                if (regionsDict.isDict(key))
+                {
+                    // Get the dictionary for region iter.keyword()
+                    const dictionary& regionDict = regionsDict.subDict(key);
+
+                    label index = findIndex(localNames, key);
+
+                    if (index == -1)
+                    {
+                        FatalErrorIn
+                        (
+                            "searchableSurfaces::searchableSurfaces"
+                            "( const IOobject&, const dictionary&)"
+                        )   << "Unknown region name " << key
+                            << " for surface " << s.name() << endl
+                            << "Valid region names are " << localNames
+                            << exit(FatalError);
+                    }
+
+                    rNames[index] = word(regionDict.lookup("name"));
+                }
+            }
+        }
+
+        surfI++;
+    }
+
+    // Trim (not really necessary since we don't allow non-dictionary entries)
+    PtrList<searchableSurface>::setSize(surfI);
+    names_.setSize(surfI);
+    regionNames_.setSize(surfI);
+    allSurfaces_.setSize(surfI);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::searchableSurfaces::findSurfaceID(const word& wantedName)
+ const
+{
+    return findIndex(names_, wantedName);
+}
+
+
+// Find any intersection
+void Foam::searchableSurfaces::findAnyIntersection
+(
+    const pointField& start,
+    const pointField& end,
+    labelList& hitSurfaces,
+    List<pointIndexHit>& hitInfo
+) const
+{
+    searchableSurfacesQueries::findAnyIntersection
+    (
+        *this,
+        allSurfaces_,
+        start,
+        end,
+        hitSurfaces,
+        hitInfo
+    );
+}
+
+
+// Find intersections of edge nearest to both endpoints.
+void Foam::searchableSurfaces::findAllIntersections
+(
+    const pointField& start,
+    const pointField& end,
+    labelListList& hitSurfaces,
+    List<List<pointIndexHit> >& hitInfo
+) const
+{
+    searchableSurfacesQueries::findAllIntersections
+    (
+        *this,
+        allSurfaces_,
+        start,
+        end,
+        hitSurfaces,
+        hitInfo
+    );
+}
+
+
+// Find nearest. Return -1 or nearest point
+void Foam::searchableSurfaces::findNearest
+(
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    labelList& nearestSurfaces,
+    List<pointIndexHit>& nearestInfo
+) const
+{
+    return searchableSurfacesQueries::findNearest
+    (
+        *this,
+        allSurfaces_,
+        samples,
+        nearestDistSqr,
+        nearestSurfaces,
+        nearestInfo
+    );
+}
+
+
+//- Calculate point which is on a set of surfaces.
+Foam::pointIndexHit Foam::searchableSurfaces::facesIntersection
+(
+    const scalar initDistSqr,
+    const scalar convergenceDistSqr,
+    const point& start
+) const
+{
+    return searchableSurfacesQueries::facesIntersection
+    (
+        *this,
+        allSurfaces_,
+        initDistSqr,
+        convergenceDistSqr,
+        start
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSurfaces.H b/src/meshTools/searchableSurface/searchableSurfaces.H
new file mode 100644
index 0000000000..acb02572e6
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSurfaces.H
@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    Foam::searchableSurfaces
+
+Description
+    Container for searchableSurfaces.
+
+SourceFiles
+    searchableSurfaces.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSurfaces_H
+#define searchableSurfaces_H
+
+#include "searchableSurface.H"
+#include "labelPair.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableSurfaces Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSurfaces
+:
+    public PtrList<searchableSurface>
+{
+    // Private data
+
+        //- Surface names
+        wordList names_;
+
+        //- Region names per surface
+        List<wordList> regionNames_;
+
+        ////- From global region name to surface and region on surface
+        //HashTable<labelPair> regionNames_;
+
+        //- Indices of all surfaces. Precalculated and stored.
+        labelList allSurfaces_;
+
+
+        //- Disallow default bitwise copy construct
+        searchableSurfaces(const searchableSurfaces&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableSurfaces&);
+
+
+public:
+
+    ClassName("searchableSurfaces");
+
+    // Constructors
+
+        //- Construct with length specified. Fill later.
+        explicit searchableSurfaces(const label);
+
+
+        ////- Construct from list of dictionaries
+        //searchableSurfaces(const IOobject&, const PtrList<dictionary>&);
+
+        //- Construct from dictionary
+        searchableSurfaces(const IOobject&, const dictionary&);
+
+
+    // Member Functions
+
+        const wordList& names() const
+        {
+            return names_;
+        }
+        wordList& names()
+        {
+            return names_;
+        }
+
+        const List<wordList>& regionNames() const
+        {
+            return regionNames_;
+        }
+        List<wordList>& regionNames()
+        {
+            return regionNames_;
+        }
+
+
+        ////- If adding surfaces 'by hand'
+        //HashTable<labelPair>& regionNames()
+        //{
+        //    return regionNames_;
+        //}
+        ////- Get surface and region for a name
+        //const labelPair& surfaceRegion(const word& globalRegion) const
+        //{
+        //    return regionNames_[globalRegion];
+        //}
+
+        //- Find index of surface. Return -1 if not found.
+        label findSurfaceID(const word& name) const;
+
+
+        // Multiple point queries.
+
+            //- Find any intersection. Return hit point information and
+            //  surface number. If multiple surfaces hit the first surface
+            //  is returned, not necessarily the nearest (to start).
+            void findAnyIntersection
+            (
+                const pointField& start,
+                const pointField& end,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            ) const;
+
+            //- Find all intersections in order from start to end. Returns for
+            //  every hit the surface and the hit info.
+            void findAllIntersections
+            (
+                const pointField& start,
+                const pointField& end,
+                labelListList& surfaces,
+                List<List<pointIndexHit> >& surfaceHits
+            ) const;
+
+            //- Find nearest. Return -1 (and a miss()) or surface and nearest
+            //  point.
+            void findNearest
+            (
+                const pointField&,
+                const scalarField& nearestDistSqr,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            ) const;
+
+
+        // Single point queries
+
+            //- Calculate point which is on a set of surfaces.
+            pointIndexHit facesIntersection
+            (
+                const scalar initialDistSqr,
+                const scalar convergenceDistSqr,
+                const point& start
+            ) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSurfacesQueries.C b/src/meshTools/searchableSurface/searchableSurfacesQueries.C
new file mode 100644
index 0000000000..7d7c6c2c1b
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSurfacesQueries.C
@@ -0,0 +1,822 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "searchableSurfacesQueries.H"
+#include "SortableList.H"
+#include "OFstream.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableSurfacesQueries, 0);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::pointIndexHit Foam::searchableSurfacesQueries::tempFindNearest
+(
+    const searchableSurface& surf,
+    const point& pt,
+    const scalar initDistSqr
+)
+{
+    pointField onePoint(1, pt);
+    scalarField oneDist(1, initDistSqr);
+    List<pointIndexHit> oneHit(1);
+    surf.findNearest(onePoint, oneDist, oneHit);
+    return oneHit[0];
+}
+
+
+// Calculate sum of distance to surfaces.
+Foam::scalar Foam::searchableSurfacesQueries::sumDistSqr
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const scalar initDistSqr,
+    const point& pt
+)
+{
+    scalar sum = 0;
+
+    forAll(surfacesToTest, testI)
+    {
+        label surfI = surfacesToTest[testI];
+
+        pointIndexHit hit
+        (
+            tempFindNearest(allSurfaces[surfI], pt, initDistSqr)
+        );
+
+        // Note: make it fall over if not hit.
+        sum += magSqr(hit.hitPoint()-pt);
+    }
+    return sum;
+}
+
+
+// Reflects the point furthest away around the triangle centre by a factor fac.
+// (triangle centre is the average of all points but the ihi. pSum is running
+//  sum of all points)
+Foam::scalar Foam::searchableSurfacesQueries::tryMorphTet
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const scalar initDistSqr,
+    List<vector>& p,
+    List<scalar>& y,
+    vector& pSum,
+    const label ihi,
+    const scalar fac
+)
+{
+    scalar fac1 = (1.0-fac)/vector::nComponents;
+    scalar fac2 = fac1-fac;
+
+    vector ptry = pSum*fac1-p[ihi]*fac2;
+
+    scalar ytry = sumDistSqr(allSurfaces, surfacesToTest, initDistSqr, ptry);
+
+    if (ytry < y[ihi])
+    {
+        y[ihi] = ytry;
+        pSum += ptry - p[ihi];
+        p[ihi] = ptry;
+    }
+    return ytry;
+}
+
+
+bool Foam::searchableSurfacesQueries::morphTet
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const scalar initDistSqr,
+    const scalar convergenceDistSqr,
+    const label maxIter,
+    List<vector>& p,
+    List<scalar>& y
+)
+{
+    vector pSum = sum(p);
+
+    autoPtr<OFstream> str;
+    label vertI = 0;
+    if (debug)
+    {
+        wordList names(surfacesToTest.size());
+        forAll(surfacesToTest, i)
+        {
+            names[i] = allSurfaces[surfacesToTest[i]].name();
+        }
+        Pout<< "searchableSurfacesQueries::morphTet : intersection of "
+            << names << " starting from points:" << p << endl;
+        str.reset(new OFstream("track.obj"));
+        meshTools::writeOBJ(str(), p[0]);
+        vertI++;
+    }
+
+    for (label iter = 0; iter < maxIter; iter++)
+    {
+        // Get the indices of highest, second-highest and lowest values.
+        label ihi, inhi, ilo;
+        {
+            SortableList<scalar> sortedY(y);
+            ilo = sortedY.indices()[0];
+            ihi = sortedY.indices()[sortedY.size()-1];
+            inhi = sortedY.indices()[sortedY.size()-2];
+        }
+
+        if (debug)
+        {
+            Pout<< "Iteration:" << iter
+                << " lowest:" << y[ilo] << " highest:" << y[ihi]
+                << " points:" << p << endl;
+
+            meshTools::writeOBJ(str(), p[ilo]);
+            vertI++;
+            str()<< "l " << vertI-1 << ' ' << vertI << nl;
+        }
+
+        if (y[ihi] < convergenceDistSqr)
+        {
+            // Get point on 0th surface.
+            Swap(p[0], p[ilo]);
+            Swap(y[0], y[ilo]);
+            return true;
+        }
+
+        // Reflection: point furthest away gets reflected.
+        scalar ytry = tryMorphTet
+        (
+            allSurfaces,
+            surfacesToTest,
+            10*y[ihi],             // search box.
+            p,
+            y,
+            pSum,
+            ihi,
+            -1.0
+        );
+
+        if (ytry <= y[ilo])
+        {
+            // If in right direction (y lower) expand by two.
+            ytry = tryMorphTet
+            (
+                allSurfaces,
+                surfacesToTest,
+                10*y[ihi],
+                p,
+                y,
+                pSum,
+                ihi,
+                2.0
+            );
+        }
+        else if (ytry >= y[inhi])
+        {
+            // If inside tet try contraction.
+
+            scalar ysave = y[ihi];
+
+            ytry = tryMorphTet
+            (
+                allSurfaces,
+                surfacesToTest,
+                10*y[ihi],
+                p,
+                y,
+                pSum,
+                ihi,
+                0.5
+            );
+
+            if (ytry >= ysave)
+            {
+                // Contract around lowest point.
+                forAll(p, i)
+                {
+                    if (i != ilo)
+                    {
+                        p[i] = 0.5*(p[i] + p[ilo]);
+                        y[i] = sumDistSqr
+                        (
+                            allSurfaces,
+                            surfacesToTest,
+                            y[ihi],
+                            p[i]
+                        );
+                    }
+                }
+                pSum = sum(p);
+            }
+        }
+    }
+
+    if (debug)
+    {
+        meshTools::writeOBJ(str(), p[0]);
+        vertI++;
+        str()<< "l " << vertI-1 << ' ' << vertI << nl;
+    }
+
+    // Failure to converge. Return best guess so far.
+    label ilo = findMin(y);
+    Swap(p[0], p[ilo]);
+    Swap(y[0], y[ilo]);
+    return false;
+}
+
+
+//// Get all intersections (in order) for single surface.
+//void Foam::searchableSurfacesQueries::findAllIntersections
+//(
+//    const searchableSurface& s,
+//    const pointField& start,
+//    const pointField& end,
+//    const vectorField& smallVec,
+//    List<List<pointIndexHit> >& surfaceHitInfo
+//)
+//{
+//    surfaceHitInfo.setSize(start.size());
+//
+//    // Current start point of vector
+//    pointField p0(start);
+//
+//    List<pointIndexHit> intersectInfo(start.size());
+//
+//    // For test whether finished doing vector.
+//    const vectorField dirVec(end-start);
+//    const scalarField magSqrDirVec(magSqr(dirVec));
+//
+//    while (true)
+//    {
+//        // Find first intersection. Synced.
+//        s.findLine(p0, end, intersectInfo);
+//
+//        label nHits = 0;
+//
+//        forAll(intersectInfo, i)
+//        {
+//            if (intersectInfo[i].hit())
+//            {
+//                nHits++;
+//
+//                label sz = surfaceHitInfo[i].size();
+//                surfaceHitInfo[i].setSize(sz+1);
+//                surfaceHitInfo[i][sz] = intersectInfo[i];
+//
+//                p0[i] = intersectInfo[i].hitPoint() + smallVec[i];
+//
+//                // If beyond endpoint set to endpoint so as not to pick up
+//                // any intersections. Could instead just filter out hits.
+//                if (((p0[i]-start[i])&dirVec[i]) > magSqrDirVec[i])
+//                {
+//                    p0[i] = end[i];
+//                }
+//            }
+//            else
+//            {
+//                // Set to endpoint to stop intersection test. See above.
+//                p0[i] = end[i];
+//            }
+//        }
+//
+//        // returnReduce(nHits) ?
+//        if (nHits == 0)
+//        {
+//            break;
+//        }
+//    }
+//}
+
+
+// Given current set of hits (allSurfaces, allInfo) merge in those coming from
+// surface surfI.
+void Foam::searchableSurfacesQueries::mergeHits
+(
+    const point& start,
+    const scalar mergeDist,
+
+    const label testI,                          // index of surface
+    const List<pointIndexHit>& surfHits,  // hits on surface
+
+    labelList& allSurfaces,
+    List<pointIndexHit>& allInfo,
+    scalarList& allDistSqr
+)
+{
+    // Precalculate distances
+    scalarList surfDistSqr(surfHits.size());
+    forAll(surfHits, i)
+    {
+        surfDistSqr[i] = magSqr(surfHits[i].hitPoint()-start);
+    }
+
+    forAll(surfDistSqr, i)
+    {
+        label index = findLower(allDistSqr, surfDistSqr[i]);
+
+        // Check if equal to lower.
+        if
+        (
+            index >= 0
+         && (mag(allDistSqr[index]-surfDistSqr[i]) < mergeDist)
+        )
+        {
+            // Same. Do not count.
+            //Pout<< "point:" << surfHits[i].hitPoint()
+            //    << " considered same as:" << allInfo[index].hitPoint()
+            //    << " within tol:" << mergeDist
+            //    << endl;
+        }
+        else
+        {
+            // Check if equal to higher
+            label next = index+1;
+            if
+            (
+                next < allDistSqr.size()
+             && (mag(allDistSqr[next]-surfDistSqr[i]) < mergeDist)
+            )
+            {
+                //Pout<< "point:" << surfHits[i].hitPoint()
+                //    << " considered same as:" << allInfo[next].hitPoint()
+                //    << " within tol:" << mergeDist
+                //    << endl;
+            }
+            else
+            {
+                // Insert after index
+                label sz = allSurfaces.size();
+                allSurfaces.setSize(sz+1);
+                allInfo.setSize(allSurfaces.size());
+                allDistSqr.setSize(allSurfaces.size());
+                // Make space.
+                for (label j = sz-1; j > index; --j)
+                {
+                    allSurfaces[j+1] = allSurfaces[j];
+                    allInfo[j+1] = allInfo[j];
+                    allDistSqr[j+1] = allDistSqr[j];
+                }
+                // Insert new value
+                allSurfaces[index+1] = testI;
+                allInfo[index+1] = surfHits[i];
+                allDistSqr[index+1] = surfDistSqr[i];
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Find any intersection
+void Foam::searchableSurfacesQueries::findAnyIntersection
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const pointField& start,
+    const pointField& end,
+    labelList& hitSurfaces,
+    List<pointIndexHit>& hitInfo
+)
+{
+    hitSurfaces.setSize(start.size());
+    hitSurfaces = -1;
+    hitInfo.setSize(start.size());
+
+    // Work arrays
+    labelList hitMap(identity(start.size()));
+    pointField p0(start);
+    pointField p1(end);
+    List<pointIndexHit> intersectInfo(start.size());
+
+    forAll(surfacesToTest, testI)
+    {
+        // Do synchronised call to all surfaces.
+        allSurfaces[surfacesToTest[testI]].findLineAny(p0, p1, intersectInfo);
+
+        // Copy all hits into arguments, continue with misses
+        label newI = 0;
+        forAll(intersectInfo, i)
+        {
+            if (intersectInfo[i].hit())
+            {
+                hitInfo[hitMap[i]] = intersectInfo[i];
+                hitSurfaces[hitMap[i]] = testI;
+            }
+            else
+            {
+                if (i != newI)
+                {
+                    hitMap[newI] = hitMap[i];
+                    p0[newI] = p0[i];
+                    p1[newI] = p1[i];
+                }
+                newI++;
+            }
+        }
+
+        // All done? Note that this decision should be synchronised
+        if (newI == 0)
+        {
+            break;
+        }
+
+        // Trim and continue
+        hitMap.setSize(newI);
+        p0.setSize(newI);
+        p1.setSize(newI);
+        intersectInfo.setSize(newI);
+    }
+}
+
+
+void Foam::searchableSurfacesQueries::findAllIntersections
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const pointField& start,
+    const pointField& end,
+    labelListList& hitSurfaces,
+    List<List<pointIndexHit> >& hitInfo
+)
+{
+    // Note: maybe move the single-surface all intersections test into
+    // searchable surface? Some of the tolerance issues might be
+    // lessened.
+
+    // 2. Currently calling searchableSurface::findLine with start==end
+    //    is expected to find no intersection. Problem if it does.
+
+    hitSurfaces.setSize(start.size());
+    hitInfo.setSize(start.size());
+
+    if (surfacesToTest.size() == 0)
+    {
+        return;
+    }
+
+    // Test first surface
+    allSurfaces[surfacesToTest[0]].findLineAll(start, end, hitInfo);
+
+    // Set hitSurfaces and distance
+    List<scalarList> hitDistSqr(hitInfo.size());
+    forAll(hitInfo, pointI)
+    {
+        const List<pointIndexHit>& pHits = hitInfo[pointI];
+
+        labelList& pSurfaces = hitSurfaces[pointI];
+        pSurfaces.setSize(pHits.size());
+        pSurfaces = 0;
+
+        scalarList& pDistSqr = hitDistSqr[pointI];
+        pDistSqr.setSize(pHits.size());
+        forAll(pHits, i)
+        {
+            pDistSqr[i] = magSqr(pHits[i].hitPoint() - start[pointI]);
+        }
+    }
+
+
+    if (surfacesToTest.size() > 1)
+    {
+        // Small vector to increment start vector by to find next intersection
+        // along line. Constant factor added to make sure that start==end still
+        // ends iteration in findAllIntersections. Also SMALL is just slightly
+        // too small.
+        const vectorField smallVec
+        (
+            1E2*SMALL*(end-start)
+          + vector(ROOTVSMALL,ROOTVSMALL,ROOTVSMALL)
+        );
+
+        // Tolerance used to check whether points are equal. Note: used to
+        // compare distance^2. Note that we use the maximum possible tolerance
+        // (reached at intersections close to the end point)
+        const scalarField mergeDist(2*mag(smallVec)*mag(end-start));
+
+        // Test the other surfaces and merge (according to distance from start).
+        for (label testI = 1; testI < surfacesToTest.size(); testI++)
+        {
+            List<List<pointIndexHit> > surfHits;
+            allSurfaces[surfacesToTest[testI]].findLineAll
+            (
+                start,
+                end,
+                surfHits
+            );
+
+            forAll(surfHits, pointI)
+            {
+                mergeHits
+                (
+                    start[pointI],          // Current segment
+                    mergeDist[pointI],
+
+                    testI,                  // Surface and its hits
+                    surfHits[pointI],
+
+                    hitSurfaces[pointI],    // Merge into overall hit info
+                    hitInfo[pointI],
+                    hitDistSqr[pointI]
+                );
+            }
+        }
+    }
+}
+
+
+//// Find intersections of edge nearest to both endpoints.
+//void Foam::searchableSurfacesQueries::findNearestIntersection
+//(
+//    const PtrList<searchableSurface>& allSurfaces,
+//    const labelList& surfacesToTest,
+//    const pointField& start,
+//    const pointField& end,
+//
+//    labelList& surface1,
+//    List<pointIndexHit>& hit1,
+//    labelList& surface2,
+//    List<pointIndexHit>& hit2
+//)
+//{
+//    // 1. intersection from start to end
+//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+//    // Initialize arguments
+//    surface1.setSize(start.size());
+//    surface1 = -1;
+//    hit1.setSize(start.size());
+//
+//    // Current end of segment to test.
+//    pointField nearest(end);
+//    // Work array
+//    List<pointIndexHit> nearestInfo(start.size());
+//
+//    forAll(surfacesToTest, testI)
+//    {
+//        // See if any intersection between start and current nearest
+//        allSurfaces[surfacesToTest[testI]].findLine
+//        (
+//            start,
+//            nearest,
+//            nearestInfo
+//        );
+//
+//        forAll(nearestInfo, pointI)
+//        {
+//            if (nearestInfo[pointI].hit())
+//            {
+//                hit1[pointI] = nearestInfo[pointI];
+//                surface1[pointI] = testI;
+//                nearest[pointI] = hit1[pointI].hitPoint();
+//            }
+//        }
+//    }
+//
+//
+//    // 2. intersection from end to last intersection
+//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+//    // Find the nearest intersection from end to start. Note that we
+//    // initialize to the first intersection (if any).
+//    surface2 = surface1;
+//    hit2 = hit1;
+//
+//    // Set current end of segment to test.
+//    forAll(nearest, pointI)
+//    {
+//        if (hit1[pointI].hit())
+//        {
+//            nearest[pointI] = hit1[pointI].hitPoint();
+//        }
+//        else
+//        {
+//            // Disable testing by setting to end.
+//            nearest[pointI] = end[pointI];
+//        }
+//    }
+//
+//    forAll(surfacesToTest, testI)
+//    {
+//        // See if any intersection between end and current nearest
+//        allSurfaces[surfacesToTest[i]].findLine(end, nearest, nearestInfo);
+//
+//        forAll(nearestInfo, pointI)
+//        {
+//            if (nearestInfo[pointI].hit())
+//            {
+//                hit2[pointI] = nearestInfo[pointI];
+//                surface2[pointI] = testI;
+//                nearest[pointI] = hit2[pointI].hitPoint();
+//            }
+//        }
+//    }
+//}
+
+
+// Find nearest. Return -1 or nearest point
+void Foam::searchableSurfacesQueries::findNearest
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    labelList& nearestSurfaces,
+    List<pointIndexHit>& nearestInfo
+)
+{
+    // Initialise
+    nearestSurfaces.setSize(samples.size());
+    nearestSurfaces = -1;
+    nearestInfo.setSize(samples.size());
+
+    // Work arrays
+    scalarField minDistSqr(nearestDistSqr);
+    List<pointIndexHit> hitInfo(samples.size());
+
+    forAll(surfacesToTest, testI)
+    {
+        allSurfaces[surfacesToTest[testI]].findNearest
+        (   
+            samples,
+            minDistSqr,
+            hitInfo
+        );
+
+        // Update minDistSqr and arguments
+        forAll(hitInfo, pointI)
+        {
+            if (hitInfo[pointI].hit())
+            {
+                minDistSqr[pointI] = magSqr
+                (   
+                    hitInfo[pointI].hitPoint()
+                  - samples[pointI]
+                );
+                nearestInfo[pointI] = hitInfo[pointI];
+                nearestSurfaces[pointI] = testI;
+            }
+        }
+    }
+}
+
+
+//- Calculate point which is on a set of surfaces.
+Foam::pointIndexHit Foam::searchableSurfacesQueries::facesIntersection
+(
+    const PtrList<searchableSurface>& allSurfaces,
+    const labelList& surfacesToTest,
+    const scalar initDistSqr,
+    const scalar convergenceDistSqr,
+    const point& start
+)
+{
+    // Get four starting points. Take these as the projection of the
+    // starting point onto the surfaces and the mid point
+    List<point> nearest(surfacesToTest.size()+1);
+
+    point sumNearest = vector::zero;
+
+    forAll(surfacesToTest, i)
+    {
+        pointIndexHit hit
+        (
+            tempFindNearest(allSurfaces[surfacesToTest[i]], start, initDistSqr)
+        );
+
+        if (hit.hit())
+        {
+            nearest[i] = hit.hitPoint();
+            sumNearest += nearest[i];
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "searchableSurfacesQueries::facesIntersection"
+                "(const labelList&, const scalar, const scalar, const point&)"
+            )   << "Did not find point within distance "
+                << initDistSqr << " of starting point " << start
+                << " on surface "
+                << allSurfaces[surfacesToTest[i]].IOobject::name()
+                << abort(FatalError);
+        }
+    }
+
+    nearest[nearest.size()-1] = sumNearest / surfacesToTest.size();
+
+
+    // Get the sum of distances (initial evaluation)
+    List<scalar> nearestDist(nearest.size());
+
+    forAll(nearestDist, i)
+    {
+        nearestDist[i] = sumDistSqr
+        (
+            allSurfaces,
+            surfacesToTest,
+            initDistSqr,
+            nearest[i]
+        );
+    }
+
+
+    //- Downhill Simplex method
+
+    bool converged = morphTet
+    (
+        allSurfaces,
+        surfacesToTest,
+        initDistSqr,
+        convergenceDistSqr,
+        2000,
+        nearest,
+        nearestDist
+    );
+
+
+    pointIndexHit intersection;
+
+    if (converged)
+    {
+        // Project nearest onto 0th surface.
+        intersection = tempFindNearest
+        (
+            allSurfaces[surfacesToTest[0]],
+            nearest[0],
+            nearestDist[0]
+        );
+    }
+
+    //if (!intersection.hit())
+    //{
+    //    // Restart
+    //    scalar smallDist = Foam::sqr(convergenceDistSqr);
+    //    nearest[0] = intersection.hitPoint();
+    //    nearest[1] = nearest[0];
+    //    nearest[1].x() += smallDist;
+    //    nearest[2] = nearest[0];
+    //    nearest[2].y() += smallDist;
+    //    nearest[3] = nearest[0];
+    //    nearest[3].z() += smallDist;
+    //
+    //    forAll(nearestDist, i)
+    //    {
+    //        nearestDist[i] = sumDistSqr
+    //        (
+    //            surfacesToTest,
+    //            initDistSqr,
+    //            nearest[i]
+    //        );
+    //    }
+    //
+    //    intersection = morphTet
+    //    (
+    //        allSurfaces,
+    //        surfacesToTest,
+    //        initDistSqr,
+    //        convergenceDistSqr,
+    //        1000,
+    //        nearest,
+    //        nearestDist
+    //    );
+    //}
+
+    return intersection;
+}
+
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSurfacesQueries.H b/src/meshTools/searchableSurface/searchableSurfacesQueries.H
new file mode 100644
index 0000000000..dcb84050a6
--- /dev/null
+++ b/src/meshTools/searchableSurface/searchableSurfacesQueries.H
@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    Foam::searchableSurfacesQueries
+
+Description
+    A collection of tools for searchableSurfaces.
+
+SourceFiles
+    searchableSurfacesQueries.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSurfacesQueries_H
+#define searchableSurfacesQueries_H
+
+#include "searchableSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class plane;
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableSurfacesQueries Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSurfacesQueries
+{
+    // Private data
+
+    // Private Member Functions
+
+        //- Temporary wrapper around findNearest. Used in facesIntersection only
+        static pointIndexHit tempFindNearest
+        (
+            const searchableSurface&,
+            const point& pt,
+            const scalar initDistSqr
+        );
+
+        //- Calculate sum of distances to nearest point on surfaces. Is used
+        //  in minimisation to find intersection. Returns sum of (square of)
+        //  distances to the surfaces.
+        static scalar sumDistSqr
+        (
+            const PtrList<searchableSurface>&,
+            const labelList& surfacesToTest,
+            const scalar initialDistSqr,    // search box
+            const point& pt
+        );
+
+        //- Takes the tet (points p) and reflects the point with the
+        //  highest value around the centre (pSum). Checks if it gets closer
+        //  and updates p, y if so.
+        static scalar tryMorphTet
+        (
+            const PtrList<searchableSurface>&,
+            const labelList& surfacesToTest,
+            const scalar initialDistSqr,
+            List<vector>& p,
+            List<scalar>& y,
+            vector& pSum,
+            const label ihi,
+            const scalar fac
+        );
+
+        //- Downhill simplex method: find the point with min cumulative
+        //  distance to all surfaces. Does so by morphing a tet (points p).
+        //  Returns the point on the 0th surface or hit if not reached within
+        //  maxIters iterations.
+        static bool morphTet
+        (
+            const PtrList<searchableSurface>&,
+            const labelList& surfacesToTest,
+            const scalar initialDistSqr,
+            const scalar convergenceDistSqr,
+            const label maxIter,
+            List<vector>& p,
+            List<scalar>& y
+        );
+
+        //static void findAllIntersections
+        //(
+        //    const searchableSurface& s,
+        //    const pointField& start,
+        //    const pointField& end,
+        //    const vectorField& smallVec,
+        //    List<List<pointIndexHit> >&
+        //);
+
+        static void mergeHits
+        (
+            const point& start,
+            const scalar mergeDist,
+
+            const label surfI,
+            const List<pointIndexHit>& surfHits,
+
+            labelList& allSurfaces,
+            List<pointIndexHit>& allInfo,
+            scalarList& allDistSqr
+        );
+
+public:
+
+    // Declare name of the class and its debug switch
+    ClassName("searchableSurfacesQueries");
+
+
+        // Multiple point queries.
+
+            //- Find any intersection. Return hit point information and
+            //  index in surfacesToTest. If multiple surfaces hit the first
+            //  surface is returned, not necessarily the nearest (to start).
+            static void findAnyIntersection
+            (
+                const PtrList<searchableSurface>&,
+                const labelList& surfacesToTest,
+                const pointField& start,
+                const pointField& end,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            );
+
+            //- Find all intersections in order from start to end. Returns for
+            //  every hit the index in surfacesToTest and the hit info.
+            static void findAllIntersections
+            (
+                const PtrList<searchableSurface>&,
+                const labelList& surfacesToTest,
+                const pointField& start,
+                const pointField& end,
+                labelListList& surfaces,
+                List<List<pointIndexHit> >& surfaceHits
+            );
+
+            //- Find nearest. Return -1 (and a miss()) or surface and nearest
+            //  point.
+            static void findNearest
+            (
+                const PtrList<searchableSurface>&,
+                const labelList& surfacesToTest,
+                const pointField&,
+                const scalarField& nearestDistSqr,
+                labelList& surfaces,
+                List<pointIndexHit>&
+            );
+
+
+        // Single point queries
+
+            //- Calculate point which is on a set of surfaces. WIP.
+            static pointIndexHit facesIntersection
+            (
+                const PtrList<searchableSurface>& allSurfaces,
+                const labelList& surfacesToTest,
+                const scalar initDistSqr,
+                const scalar convergenceDistSqr,
+                const point& start
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.C b/src/meshTools/searchableSurface/triSurfaceMesh.C
new file mode 100644
index 0000000000..526646c014
--- /dev/null
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.C
@@ -0,0 +1,552 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "triSurfaceMesh.H"
+#include "Random.H"
+#include "addToRunTimeSelectionTable.H"
+#include "EdgeMap.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(triSurfaceMesh, 0);
+addToRunTimeSelectionTable(searchableSurface, triSurfaceMesh, dict);
+
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+//- Check file existence
+const Foam::fileName& Foam::triSurfaceMesh::checkFile
+(
+    const fileName& fName,
+    const fileName& objectName
+)
+{
+    if (fName == fileName::null)
+    {
+        FatalErrorIn
+        (
+            "triSurfaceMesh::checkFile(const fileName&, const fileName&)"
+        )   << "Cannot find triSurfaceMesh starting from "
+            << objectName << exit(FatalError);
+    }
+    return fName;
+}
+
+
+bool Foam::triSurfaceMesh::isSurfaceClosed() const
+{
+    // Construct pointFaces. Let's hope surface has compact point
+    // numbering ...
+    labelListList pointFaces;
+    invertManyToMany(points().size(), *this, pointFaces);
+
+    // Loop over all faces surrounding point. Count edges emanating from point.
+    // Every edge should be used by two faces exactly.
+    // To prevent doing work twice per edge only look at edges to higher
+    // point
+    EdgeMap<label> facesPerEdge(100);
+    forAll(pointFaces, pointI)
+    {
+        const labelList& pFaces = pointFaces[pointI];
+
+        facesPerEdge.clear();
+        forAll(pFaces, i)
+        {
+            const labelledTri& f = triSurface::operator[](pFaces[i]);
+            label fp = findIndex(f, pointI);
+
+            // Forward edge
+            {
+                label p1 = f[f.fcIndex(fp)];
+
+                if (p1 > pointI)
+                {
+                    const edge e(pointI, p1);
+                    EdgeMap<label>::iterator eFnd = facesPerEdge.find(e);
+                    if (eFnd != facesPerEdge.end())
+                    {
+                        if (eFnd() == 2)
+                        {
+                            return false;
+                        }
+                        eFnd()++;
+                    }
+                    else
+                    {
+                        facesPerEdge.insert(e, 1);
+                    }
+                }
+            }
+            // Reverse edge
+            {
+                label p1 = f[f.rcIndex(fp)];
+
+                if (p1 > pointI)
+                {
+                    const edge e(pointI, p1);
+                    EdgeMap<label>::iterator eFnd = facesPerEdge.find(e);
+                    if (eFnd != facesPerEdge.end())
+                    {
+                        if (eFnd() == 2)
+                        {
+                            return false;
+                        }
+                        eFnd()++;
+                    }
+                    else
+                    {
+                        facesPerEdge.insert(e, 1);
+                    }
+                }
+            }
+        }
+
+        // Check for any edges used only once.
+        forAllConstIter(EdgeMap<label>, facesPerEdge, iter)
+        {
+            if (iter() != 2)
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::triSurfaceMesh::triSurfaceMesh(const IOobject& io, const triSurface& s)
+:
+    searchableSurface(io),
+    objectRegistry(io),
+    triSurface(s),
+    surfaceClosed_(-1)
+{}
+
+
+Foam::triSurfaceMesh::triSurfaceMesh(const IOobject& io)
+:
+    searchableSurface(io),
+    objectRegistry(io),
+    triSurface
+    (
+        checkFile
+        (
+            searchableSurface::filePath(),
+            searchableSurface::objectPath()
+        )
+    ),
+    surfaceClosed_(-1)
+{}
+
+
+Foam::triSurfaceMesh::triSurfaceMesh
+(
+    const IOobject& io,
+    const dictionary& dict
+)
+:
+    searchableSurface(io),
+    objectRegistry(io),
+    triSurface
+    (
+        checkFile
+        (
+            searchableSurface::filePath(),
+            searchableSurface::objectPath()
+        )
+    ),
+    surfaceClosed_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::triSurfaceMesh::~triSurfaceMesh()
+{
+    clearOut();
+}
+
+
+void Foam::triSurfaceMesh::clearOut()
+{
+    tree_.clear();
+    edgeTree_.clear();
+    triSurface::clearOut();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::triSurfaceMesh::movePoints(const pointField& newPoints)
+{
+    tree_.clear();
+    edgeTree_.clear();
+    triSurface::movePoints(newPoints);
+}
+
+
+const Foam::indexedOctree<Foam::treeDataTriSurface>&
+    Foam::triSurfaceMesh::tree() const
+{
+    if (!tree_.valid())
+    {
+        treeBoundBox bb(points(), meshPoints());
+
+        // Random number generator. Bit dodgy since not exactly random ;-)
+        Random rndGen(65431);
+
+        tree_.reset
+        (
+            new indexedOctree<treeDataTriSurface>
+            (
+                treeDataTriSurface(*this),
+                bb.extend(rndGen, 1E-3),    // slightly randomize bb
+                10,     // maxLevel
+                10,     // leafsize
+                3.0     // duplicity
+            )
+        );
+    }
+
+    return tree_();
+}
+
+
+const Foam::indexedOctree<Foam::treeDataEdge>&
+    Foam::triSurfaceMesh::edgeTree() const
+{
+    if (!edgeTree_.valid())
+    {
+        treeBoundBox bb(localPoints());
+
+        // Boundary edges
+        labelList bEdges
+        (
+            identity
+            (
+                nEdges()
+               -nInternalEdges()
+            )
+          + nInternalEdges()
+        );
+
+        // Random number generator. Bit dodgy since not exactly random ;-)
+        Random rndGen(65431);
+
+        edgeTree_.reset
+        (
+            new indexedOctree<treeDataEdge>
+            (
+                treeDataEdge
+                (
+                    false,          // cachebb
+                    edges(),        // edges
+                    localPoints(),  // points
+                    bEdges          // selected edges
+                ),
+                bb.extend(rndGen, 1E-3),    // slightly randomize bb
+                8,      // maxLevel
+                10,     // leafsize
+                3.0     // duplicity
+            )
+        );
+    }
+    return edgeTree_();
+}
+
+
+const Foam::wordList& Foam::triSurfaceMesh::regions() const
+{
+    if (regions_.size() == 0)
+    {
+        regions_.setSize(patches().size());
+        forAll(regions_, regionI)
+        {
+            regions_[regionI] = patches()[regionI].name();
+        }
+    }
+    return regions_;
+}
+
+
+//Foam::pointIndexHit Foam::triSurfaceMesh::findNearest
+//(
+//    const point& sample,
+//    const scalar nearestDistSqr
+//) const
+//{
+//    return tree().findNearest(sample, nearestDistSqr);
+//}
+//
+//
+//Foam::pointIndexHit Foam::triSurfaceMesh::findNearestOnEdge
+//(
+//    const point& sample,
+//    const scalar nearestDistSqr
+//) const
+//{
+//    return = edgeTree().findNearest(sample, nearestDistSqr);
+//}
+//
+//
+//Foam::pointIndexHit Foam::triSurfaceMesh::findNearest
+//(
+//    const linePointRef& ln,
+//    treeBoundBox& tightest,
+//    point& linePoint
+//) const
+//{
+//    return tree().findNearest(ln, tightest, linePoint);
+//}
+//
+//
+//Foam::pointIndexHit Foam::triSurfaceMesh::findLine
+//(
+//    const point& start,
+//    const point& end
+//) const
+//{
+//    return tree().findLine(start, end);
+//}
+//
+//
+//Foam::pointIndexHit Foam::triSurfaceMesh::findLineAny
+//(
+//    const point& start,
+//    const point& end
+//) const
+//{
+//    return tree().findLineAny(start, end);
+//}
+
+
+// Find out if surface is closed.
+bool Foam::triSurfaceMesh::hasVolumeType() const
+{
+    if (surfaceClosed_ == -1)
+    {
+        if (isSurfaceClosed())
+        {
+            surfaceClosed_ = 1;
+        }
+        else
+        {
+            surfaceClosed_ = 0;
+        }
+    }
+
+    return surfaceClosed_ == 1;
+}
+
+
+void Foam::triSurfaceMesh::findNearest
+(
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    List<pointIndexHit>& info
+) const
+{
+    const indexedOctree<treeDataTriSurface>& octree = tree();
+
+    info.setSize(samples.size());
+
+    forAll(samples, i)
+    {
+        static_cast<pointIndexHit&>(info[i]) =
+            octree.findNearest(samples[i], nearestDistSqr[i]);
+    }
+}
+
+
+void Foam::triSurfaceMesh::findLine
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    const indexedOctree<treeDataTriSurface>& octree = tree();
+
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        static_cast<pointIndexHit&>(info[i]) = octree.findLine
+        (
+            start[i],
+            end[i]
+        );
+    }
+}
+
+
+void Foam::triSurfaceMesh::findLineAny
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    const indexedOctree<treeDataTriSurface>& octree = tree();
+
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        static_cast<pointIndexHit&>(info[i]) =
+            octree.findLineAny(start[i], end[i]);
+    }
+}
+
+
+void Foam::triSurfaceMesh::findLineAll
+(
+    const pointField& start,
+    const pointField& end,
+    List<List<pointIndexHit> >& info
+) const
+{
+    const indexedOctree<treeDataTriSurface>& octree = tree();
+
+    info.setSize(start.size());
+
+    // Work array
+    DynamicList<pointIndexHit, 1, 1> hits;
+
+    // Tolerances
+    const vectorField dirVec(end-start);
+    const scalarField magSqrDirVec(magSqr(dirVec));
+    const vectorField smallVec
+    (
+        Foam::sqrt(SMALL)*dirVec
+      + vector(ROOTVSMALL,ROOTVSMALL,ROOTVSMALL)
+    );
+
+    forAll(start, pointI)
+    {
+        hits.clear();
+
+        // Current starting point of ray.
+        point pt = start[pointI];
+
+        while (true)
+        {
+            // See if any intersection between pt and end
+            pointIndexHit inter = octree.findLine(pt, end[pointI]);
+
+            if (!inter.hit())
+            {
+                break;
+            }
+            hits.append(inter);
+
+            pt = inter.hitPoint() + smallVec[pointI];
+
+            if (((pt-start[pointI])&dirVec[pointI]) > magSqrDirVec[pointI])
+            {
+                // Adding smallVec has taken us beyond end
+                break;
+            }
+        }
+
+        hits.shrink();
+        info[pointI].transfer(hits);
+        hits.clear();
+    }
+}
+
+
+void Foam::triSurfaceMesh::getRegion
+(
+    const List<pointIndexHit>& info,
+    labelList& region
+) const
+{
+    region.setSize(info.size());
+    forAll(info, i)
+    {
+        if (info[i].hit())
+        {
+            region[i] = triSurface::operator[](info[i].index()).region();
+        }
+        else
+        {
+            region[i] = -1;
+        }
+    }
+}
+
+
+void Foam::triSurfaceMesh::getNormal
+(
+    const List<pointIndexHit>& info,
+    vectorField& normal
+) const
+{
+    normal.setSize(info.size());
+
+    forAll(info, i)
+    {
+        if (info[i].hit())
+        {
+            normal[i] = faceNormals()[info[i].index()];
+        }
+        else
+        {
+            // Set to what?
+            normal[i] = vector::zero;
+        }
+    }
+}
+
+
+void Foam::triSurfaceMesh::getVolumeType
+(
+    const pointField& points,
+    List<volumeType>& volType
+) const
+{
+    volType.setSize(points.size());
+
+    forAll(points, pointI)
+    {
+        const point& pt = points[pointI];
+
+        // - use cached volume type per each tree node
+        // - cheat conversion since same values
+        volType[pointI] = static_cast<volumeType>(tree().getVolumeType(pt));
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/triSurface/searchableSurface/triSurfaceMesh.H b/src/meshTools/searchableSurface/triSurfaceMesh.H
similarity index 64%
rename from src/meshTools/triSurface/searchableSurface/triSurfaceMesh.H
rename to src/meshTools/searchableSurface/triSurfaceMesh.H
index 453b4daa61..1b9fa0c945 100644
--- a/src/meshTools/triSurface/searchableSurface/triSurfaceMesh.H
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -54,7 +54,7 @@ namespace Foam
 class triSurfaceMesh
 :
     public searchableSurface,
-    public objectRegistry,
+    public objectRegistry,      // so we can store fields
     public triSurface
 {
 private:
@@ -67,6 +67,12 @@ private:
         //- Search tree for boundary edges.
         mutable autoPtr<indexedOctree<treeDataEdge> > edgeTree_;
 
+        //- Names of regions
+        mutable wordList regions_;
+
+        //- Is surface closed
+        mutable label surfaceClosed_;
+
     // Private Member Functions
 
         //- Check file existence
@@ -76,6 +82,10 @@ private:
             const fileName& objectName
         );
 
+        //- Check whether surface is closed without calculating any permanent
+        //  addressing.
+        bool isSurfaceClosed() const;
+
         //- Disallow default bitwise copy construct
         triSurfaceMesh(const triSurfaceMesh&);
 
@@ -97,11 +107,10 @@ public:
         //- Construct read
         triSurfaceMesh(const IOobject& io);
 
-        //- Construct as searchableSurface
+        //- Construct from dictionary (used by searchableSurface)
         triSurfaceMesh
         (
-            const word& name,
-            const objectRegistry& obj,
+            const IOobject& io,
             const dictionary& dict
         );
 
@@ -128,57 +137,73 @@ public:
 
         // 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
+            virtual const wordList& regions() const;
+
+            //- Whether supports volume type below. I.e. whether is closed.
+            virtual bool hasVolumeType() const;
+
+
+        // Multiple point queries.
+
+            virtual void findNearest
             (
-                const point& sample,
-                const scalar nearestDistSqr
+                const pointField& sample,
+                const scalarField& nearestDistSqr,
+                List<pointIndexHit>&
             ) 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
+            virtual void findLine
             (
-                const point& sample,
-                const scalar nearestDistSqr
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
             ) 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
+            virtual void findLineAny
             (
-                const linePointRef& ln,
-                treeBoundBox& tightest,
-                point& linePoint
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
             ) const;
 
-            //- Find nearest intersection of line between start and end.
-            virtual pointIndexHit findLine
+            //- Get all intersections in order from start to end.
+            virtual void findLineAll
             (
-                const point& start,
-                const point& end
+                const pointField& start,
+                const pointField& end,
+                List<List<pointIndexHit> >&
             ) const;
 
-            //- Find any intersection of line between start and end.
-            virtual pointIndexHit findLineAny
+            //- From a set of points and indices get the region
+            virtual void getRegion
             (
-                const point& start,
-                const point& end
+                const List<pointIndexHit>&,
+                labelList& region
+            ) const;
+
+            //- From a set of points and indices get the normal
+            virtual void getNormal
+            (
+                const List<pointIndexHit>&,
+                vectorField& normal
             ) const;
 
             //- Determine type (inside/outside/mixed) for point. unknown if
             //  cannot be determined (e.g. non-manifold surface)
-            virtual volumeType getVolumeType(const point&) const;
+            virtual void getVolumeType
+            (
+                const pointField&,
+                List<volumeType>&
+            ) const;
+
+
+        // regIOobject implementation
+
+            bool writeData(Ostream&) const
+            {
+                notImplemented("triSurfaceMesh::writeData(Ostream&) const");
+                return false;
+            }
 
 };
 
diff --git a/src/meshTools/triSurface/searchableSurface/searchableBox.C b/src/meshTools/triSurface/searchableSurface/searchableBox.C
deleted file mode 100644
index 77e48c3a8e..0000000000
--- a/src/meshTools/triSurface/searchableSurface/searchableBox.C
+++ /dev/null
@@ -1,247 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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 "searchableBox.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-defineTypeNameAndDebug(searchableBox, 0);
-addToRunTimeSelectionTable(searchableSurface, searchableBox, dict);
-
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::searchableBox::searchableBox
-(
-    const word& name,
-    const treeBoundBox& bb
-)
-:
-    searchableSurface(name),
-    treeBoundBox(bb)
-{}
-
-
-Foam::searchableBox::searchableBox
-(
-    const word& name,
-    const objectRegistry& obj,
-    const dictionary& dict
-)
-:
-    searchableSurface(name),
-    treeBoundBox(dict.lookup("min"), dict.lookup("max"))
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::searchableBox::~searchableBox()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::pointIndexHit Foam::searchableBox::findNearest
-(
-    const point& sample,
-    const scalar nearestDistSqr
-) const
-{
-    // Point can be inside or outside. For every component direction can be
-    // left of min, right of max or inbetween.
-    // - outside points: project first one x plane (either min().x()
-    // or max().x()), then onto y plane and finally z. You should be left
-    // with intersection point
-    // - inside point: find nearest side (compare to mid point). Pick any
-    // one of three points.
-
-    const point bbMid(mid());
-
-    // Outside point projected onto cube
-    point interPt(sample);
-    bool outside = false;
-
-    // (for internal points) Per direction what nearest cube side is
-    point near;
-
-    for (direction dir = 0; dir < vector::nComponents; dir++)
-    {
-        if (interPt[dir] < min()[dir])
-        {
-            interPt[dir] = min()[dir];
-            outside = true;
-        }
-        else if (interPt[dir] > max()[dir])
-        {
-            interPt[dir] = max()[dir];
-            outside = true;
-        }
-        else if (interPt[dir] > bbMid[dir])
-        {
-            near[dir] = max()[dir];
-        }
-        else
-        {
-            near[dir] = min()[dir];
-        }
-    }
-
-
-    // For outside points the interPt will be correct now. Handle inside points
-    // using the three near distances. Project onto the nearest plane.
-    if (!outside)
-    {
-        vector dist(cmptMag(interPt - near));
-
-        if (dist.x() < dist.y())
-        {
-            if (dist.x() < dist.z())
-            {
-                interPt.x() = near.x();
-            }
-            else
-            {
-                interPt.z() = near.z();
-            }
-        }
-        else
-        {
-            if (dist.y() < dist.z())
-            {
-                interPt.y() = near.y();
-            }
-            else
-            {
-                interPt.z() = near.z();
-            }
-        }
-    }
-
-    return pointIndexHit(true, interPt, 0);
-}
-
-
-Foam::pointIndexHit Foam::searchableBox::findNearestOnEdge
-(
-    const point& sample,
-    const scalar nearestDistSqr
-) const
-{
-    const point bbMid(mid());
-
-    point interPt(sample);
-
-    for (direction dir = 0; dir < vector::nComponents; dir++)
-    {
-        // Project onto left or right depending on mid
-        if (interPt[dir] > bbMid[dir])
-        {
-            interPt[dir] = max()[dir];
-        }
-        else
-        {
-            interPt[dir] = min()[dir];
-        }
-    }
-
-    return pointIndexHit(true, interPt, 0);
-}
-
-
-Foam::pointIndexHit Foam::searchableBox::findNearest
-(
-    const linePointRef& ln,
-    treeBoundBox& tightest,
-    point& linePoint
-) const
-{
-    notImplemented
-    (
-        "searchableBox::findNearest"
-        "(const linePointRef&, treeBoundBox&, point&)"
-    );
-    return pointIndexHit();
-}
-
-
-Foam::pointIndexHit Foam::searchableBox::findLine
-(
-    const point& start,
-    const point& end
-) const
-{
-    point intPt;
-    bool foundInter = intersects(start, end, intPt);
-
-    return pointIndexHit(foundInter, intPt, 0);
-}
-
-
-Foam::pointIndexHit Foam::searchableBox::findLineAny
-(
-    const point& start,
-    const point& end
-) const
-{
-    return findLine(start, end);
-}
-
-
-Foam::searchableSurface::volumeType Foam::searchableBox::getVolumeType
-(
-    const point& pt
-) const
-{
-    for (direction dir = 0; dir < vector::nComponents; dir++)
-    {
-        if (pt[dir] < min()[dir] || pt[dir] > max()[dir])
-        {
-            return OUTSIDE;
-        }
-    }
-
-    return INSIDE;
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/triSurface/searchableSurface/searchableBox.H b/src/meshTools/triSurface/searchableSurface/searchableBox.H
deleted file mode 100644
index 4a347af46a..0000000000
--- a/src/meshTools/triSurface/searchableSurface/searchableBox.H
+++ /dev/null
@@ -1,161 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::searchableBox
-
-Description
-    Searching on bounding box
-
-SourceFiles
-    searchableBox.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef searchableBox_H
-#define searchableBox_H
-
-#include "searchableSurface.H"
-#include "treeBoundBox.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-
-/*---------------------------------------------------------------------------*\
-                           Class searchableBox Declaration
-\*---------------------------------------------------------------------------*/
-
-class searchableBox
-:
-    public searchableSurface,
-    public treeBoundBox
-{
-private:
-
-    // Private member data
-
-
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        searchableBox(const searchableBox&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const searchableBox&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("searchableBox");
-
-
-    // Constructors
-
-        //- Construct from components
-        searchableBox(const word& name, const treeBoundBox& bb);
-
-        searchableBox
-        (
-            const word& name,
-            const objectRegistry& obj,
-            const dictionary& dict
-        );
-
-    // Destructor
-
-        virtual ~searchableBox();
-
-
-    // Member Functions
-
-        //- 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;
-
-        //- Find nearest intersection of line between start and end.
-        virtual pointIndexHit findLine
-        (
-            const point& start,
-            const point& end
-        ) const;
-
-        //- Find any intersection of line between start and end.
-        virtual pointIndexHit findLineAny
-        (
-            const point& start,
-            const point& end
-        ) const;
-
-        //- 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/meshTools/triSurface/searchableSurface/searchableSurface.H b/src/meshTools/triSurface/searchableSurface/searchableSurface.H
deleted file mode 100644
index 83f7aaf929..0000000000
--- a/src/meshTools/triSurface/searchableSurface/searchableSurface.H
+++ /dev/null
@@ -1,257 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::searchableSurface
-
-Description
-    Base class of (analytical or triangulated) surface.
-    Encapsulates all the search routines.
-
-SourceFiles
-    searchableSurface.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef searchableSurface_H
-#define searchableSurface_H
-
-#include "pointField.H"
-#include "typeInfo.H"
-#include "runTimeSelectionTables.H"
-#include "pointIndexHit.H"
-#include "linePointRef.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class objectRegistry;
-class treeBoundBox;
-
-/*---------------------------------------------------------------------------*\
-                           Class searchableSurface Declaration
-\*---------------------------------------------------------------------------*/
-
-class searchableSurface
-{
-public:
-
-    // Data types
-
-        //- volume types
-        enum volumeType
-        {
-            UNKNOWN = 0,
-            MIXED = 1,
-            INSIDE = 2,
-            OUTSIDE = 3
-        };
-
-private:
-
-    // Private data
-
-        const word name_;
-
-
-    // Private Member Functions
-
-        //- Disallow default bitwise copy construct
-        searchableSurface(const searchableSurface&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const searchableSurface&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("searchableSurface");
-
-    // Declare run-time constructor selection table
-
-        // For the dictionary constructor
-        declareRunTimeSelectionTable
-        (
-            autoPtr,
-            searchableSurface,
-            dict,
-            (
-                const word& name,
-                const objectRegistry& obj,
-                const dictionary& dict
-            ),
-            (name, obj, dict)
-        );
-
-        //// For the Istream constructor
-        //declareRunTimeSelectionTable
-        //(
-        //    autoPtr,
-        //    searchableSurface,
-        //    istream,
-        //    (
-        //        const objectRegistry& obj,
-        //        Istream& is
-        //    ),
-        //    (obj, is)
-        //);
-
-
-        //- Class used for the read-construction of
-        //  PtrLists of searchableSurface
-        class iNew
-        {
-            const objectRegistry& obj_;
-
-        public:
-
-            iNew(const objectRegistry& obj)
-            :
-                obj_(obj)
-            {}
-
-            autoPtr<searchableSurface> operator()(Istream& is) const
-            {
-                word surfaceType(is);
-                word name(is);
-                dictionary dict(is);
-                return searchableSurface::New(surfaceType, name, obj_, dict);
-            }
-        };
-
-
-    // Constructors
-
-        searchableSurface(const word& name);
-
-        //- Clone
-        virtual autoPtr<searchableSurface> clone() const
-        {
-            notImplemented("autoPtr<searchableSurface> clone() const");
-            return autoPtr<searchableSurface>(NULL);
-        }
-
-
-    // Selectors
-
-        //- Return a reference to the selected searchableSurface
-        static autoPtr<searchableSurface> New
-        (
-            const word& surfaceType,
-            const word& name,
-            const objectRegistry& obj,
-            const dictionary& dict
-        );
-
-        ////- Return a reference to the selected searchableSurface
-        //static autoPtr<searchableSurface> New
-        //(
-        //    const word& surfaceType,
-        //    const objectRegistry& obj,
-        //    Istream& is
-        //);
-
-
-    // Destructor
-
-        virtual ~searchableSurface();
-
-
-    // Member Functions
-
-        //- Return name
-        const word& name() const
-        {
-            return name_;
-        }
-
-        //- 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 = 0;
-
-        //- 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 = 0;
-
-        //- Find nearest to segment. 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 = 0;
-
-        //- Find nearest intersection of line between start and end.
-        virtual pointIndexHit findLine
-        (
-            const point& start,
-            const point& end
-        ) const = 0;
-
-        //- Find any intersection of line between start and end.
-        virtual pointIndexHit findLineAny
-        (
-            const point& start,
-            const point& end
-        ) const = 0;
-
-        //- Determine type (inside/outside/mixed) for point. unknown if
-        //  cannot be determined (e.g. non-manifold surface)
-        virtual volumeType getVolumeType(const point&) const = 0;
-
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/meshTools/triSurface/searchableSurface/triSurfaceMesh.C b/src/meshTools/triSurface/searchableSurface/triSurfaceMesh.C
deleted file mode 100644
index ec17352f99..0000000000
--- a/src/meshTools/triSurface/searchableSurface/triSurfaceMesh.C
+++ /dev/null
@@ -1,271 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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 "triSurfaceMesh.H"
-#include "Random.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-defineTypeNameAndDebug(triSurfaceMesh, 0);
-addToRunTimeSelectionTable(searchableSurface, triSurfaceMesh, dict);
-
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-//- Check file existence
-const Foam::fileName& Foam::triSurfaceMesh::checkFile
-(
-    const fileName& fName,
-    const fileName& objectName
-)
-{
-    if (fName == fileName::null)
-    {
-        FatalErrorIn
-        (
-            "triSurfaceMesh::checkFile(const fileName&, const fileName&)"
-        )   << "Cannot find triSurfaceMesh starting from "
-            << objectName << exit(FatalError);
-    }
-    return fName;
-}
-
-
-const Foam::indexedOctree<Foam::treeDataTriSurface>&
-    Foam::triSurfaceMesh::tree() const
-{
-    if (!tree_.valid())
-    {
-        treeBoundBox bb(points(), meshPoints());
-
-        // Random number generator. Bit dodgy since not exactly random ;-)
-        Random rndGen(65431);
-
-        tree_.reset
-        (
-            new indexedOctree<treeDataTriSurface>
-            (
-                treeDataTriSurface(*this),
-                bb.extend(rndGen, 1E-3),    // slightly randomize bb
-                8,      // maxLevel
-                10,     // leafsize
-                3.0     // duplicity
-            )
-        );
-    }
-
-    return tree_();
-}
-
-
-const Foam::indexedOctree<Foam::treeDataEdge>&
-    Foam::triSurfaceMesh::edgeTree() const
-{
-    if (!edgeTree_.valid())
-    {
-        treeBoundBox bb(localPoints());
-
-        // Boundary edges
-        labelList bEdges
-        (
-            identity
-            (
-                nEdges()
-               -nInternalEdges()
-            )
-          + nInternalEdges()
-        );
-
-        // Random number generator. Bit dodgy since not exactly random ;-)
-        Random rndGen(65431);
-
-        edgeTree_.reset
-        (
-            new indexedOctree<treeDataEdge>
-            (
-                treeDataEdge
-                (
-                    false,          // cachebb
-                    edges(),        // edges
-                    localPoints(),  // points
-                    bEdges          // selected edges
-                ),
-                bb.extend(rndGen, 1E-3),    // slightly randomize bb
-                8,      // maxLevel
-                10,     // leafsize
-                3.0     // duplicity
-            )
-        );
-    }
-    return edgeTree_();
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-//- Construct from triangles, patches, points.
-Foam::triSurfaceMesh::triSurfaceMesh(const IOobject& io, const triSurface& s)
-:
-    searchableSurface(io.name()),
-    objectRegistry(io),
-    triSurface(s)
-{}
-
-
-Foam::triSurfaceMesh::triSurfaceMesh(const IOobject& io)
-:
-    searchableSurface(io.name()),
-    objectRegistry(io),
-    triSurface(checkFile(filePath(), objectPath()))
-{}
-
-
-Foam::triSurfaceMesh::triSurfaceMesh
-(
-    const word& name,
-    const objectRegistry& obj,
-    const dictionary& dict
-)
-:
-    searchableSurface(name),
-    objectRegistry
-    (
-        IOobject
-        (
-            name,
-            "constant",
-            "triSurface",
-            obj,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        )
-    ),
-    triSurface(checkFile(filePath(), objectPath()))
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::triSurfaceMesh::~triSurfaceMesh()
-{}
-
-
-void Foam::triSurfaceMesh::clearOut()
-{
-    tree_.clear();
-    edgeTree_.clear();
-    triSurface::clearOut();
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::triSurfaceMesh::movePoints(const pointField& newPoints)
-{
-    tree_.clear();
-    edgeTree_.clear();
-    triSurface::movePoints(newPoints);    
-}
-
-
-Foam::pointIndexHit Foam::triSurfaceMesh::findNearest
-(
-    const point& sample,
-    const scalar nearestDistSqr
-) const
-{
-    return tree().findNearest(sample, nearestDistSqr);
-}
-
-
-Foam::pointIndexHit Foam::triSurfaceMesh::findNearestOnEdge
-(
-    const point& sample,
-    const scalar nearestDistSqr
-) const
-{
-    return edgeTree().findNearest(sample, nearestDistSqr);
-}
-
-
-Foam::pointIndexHit Foam::triSurfaceMesh::findNearest
-(
-    const linePointRef& ln,
-    treeBoundBox& tightest,
-    point& linePoint
-) const
-{
-    return tree().findNearest(ln, tightest, linePoint);
-}
-
-
-Foam::pointIndexHit Foam::triSurfaceMesh::findLine
-(
-    const point& start,
-    const point& end
-) const
-{
-    return tree().findLine(start, end);
-}
-
-
-Foam::pointIndexHit Foam::triSurfaceMesh::findLineAny
-(
-    const point& start,
-    const point& end
-) const
-{
-    return tree().findLineAny(start, end);
-}
-
-
-Foam::searchableSurface::volumeType
- Foam::triSurfaceMesh::getVolumeType
-(
-    const point& pt
-) const
-{
-    // - use cached volume type per each tree node
-    // - cheat conversion since same values
-    return static_cast<volumeType>(tree().getVolumeType(pt));
-}
-
-
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.C b/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.C
deleted file mode 100644
index e96c618854..0000000000
--- a/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.C
+++ /dev/null
@@ -1,916 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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 "triSurfaceMeshes.H"
-#include "Random.H"
-#include "Time.H"
-#include "SortableList.H"
-#include "IOmanip.H"
-#include "plane.H"
-#include "SortableList.H"
-#include "triSurfaceTools.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-defineTypeNameAndDebug(triSurfaceMeshes, 0);
-
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// Calculate sum of distance to surfaces.
-Foam::scalar Foam::triSurfaceMeshes::sumDistSqr
-(
-    const labelList& surfacesToTest,
-    const scalar initDistSqr,
-    const point& pt
-) const
-{
-    scalar sum = 0;
-
-    forAll(surfacesToTest, i)
-    {
-        label surfI = surfacesToTest[i];
-
-        pointIndexHit hit(operator[](surfI).findNearest(pt, initDistSqr));
-
-        // Note: make it fall over if not hit.
-        sum += magSqr(hit.hitPoint()-pt);
-    }
-    return sum;
-}
-
-
-// Reflects the point furthest away around the triangle centre by a factor fac.
-// (triangle centre is the average of all points but the ihi. pSum is running
-//  sum of all points)
-Foam::scalar Foam::triSurfaceMeshes::tryMorphTet
-(
-    const labelList& surfacesToTest,
-    const scalar initDistSqr,
-    List<vector>& p,
-    List<scalar>& y,
-    vector& pSum,
-    const label ihi,
-    const scalar fac
-) const
-{
-    scalar fac1 = (1.0-fac)/vector::nComponents;
-    scalar fac2 = fac1-fac;
-
-    vector ptry = pSum*fac1-p[ihi]*fac2;
-
-    scalar ytry = sumDistSqr(surfacesToTest, initDistSqr, ptry);
-
-    if (ytry < y[ihi])
-    {
-        y[ihi] = ytry;
-        pSum += ptry - p[ihi];
-        p[ihi] = ptry;
-    }
-    return ytry;
-}
-
-
-bool Foam::triSurfaceMeshes::morphTet
-(
-    const labelList& surfacesToTest,
-    const scalar initDistSqr,
-    const scalar convergenceDistSqr,
-    const label maxIter,
-    List<vector>& p,
-    List<scalar>& y
-) const
-{
-    vector pSum = sum(p);
-
-    autoPtr<OFstream> str;
-    label vertI = 0;
-    if (debug)
-    {
-        Pout<< "triSurfaceMeshes::morphTet : intersection of "
-            << IndirectList<fileName>(names(), surfacesToTest)()
-            << " starting from points:" << p << endl;
-        str.reset(new OFstream("track.obj"));
-        meshTools::writeOBJ(str(), p[0]);
-        vertI++;
-    }
-
-    for (label iter = 0; iter < maxIter; iter++)
-    {
-        // Get the indices of highest, second-highest and lowest values.
-        label ihi, inhi, ilo;
-        {
-            SortableList<scalar> sortedY(y);
-            ilo = sortedY.indices()[0];
-            ihi = sortedY.indices()[sortedY.size()-1];
-            inhi = sortedY.indices()[sortedY.size()-2];
-        }
-
-        if (debug)
-        {
-            Pout<< "Iteration:" << iter
-                << " lowest:" << y[ilo] << " highest:" << y[ihi]
-                << " points:" << p << endl;
-
-            meshTools::writeOBJ(str(), p[ilo]);
-            vertI++;
-            str()<< "l " << vertI-1 << ' ' << vertI << nl;
-        }
-
-        if (y[ihi] < convergenceDistSqr)
-        {
-            // Get point on 0th surface.
-            Swap(p[0], p[ilo]);
-            Swap(y[0], y[ilo]);
-            return true;
-        }
-
-        // Reflection: point furthest away gets reflected.
-        scalar ytry = tryMorphTet
-        (
-            surfacesToTest,
-            10*y[ihi],             // search box.
-            p,
-            y,
-            pSum,
-            ihi,
-            -1.0
-        );
-
-        if (ytry <= y[ilo])
-        {
-            // If in right direction (y lower) expand by two.
-            ytry = tryMorphTet(surfacesToTest, 10*y[ihi], p, y, pSum, ihi, 2.0);
-        }
-        else if (ytry >= y[inhi])
-        {
-            // If inside tet try contraction.
-
-            scalar ysave = y[ihi];
-
-            ytry = tryMorphTet(surfacesToTest, 10*y[ihi], p, y, pSum, ihi, 0.5);
-
-            if (ytry >= ysave)
-            {
-                // Contract around lowest point.
-                forAll(p, i)
-                {
-                    if (i != ilo)
-                    {
-                        p[i] = 0.5*(p[i] + p[ilo]);
-                        y[i] = sumDistSqr(surfacesToTest, y[ihi], p[i]);
-                    }
-                }
-                pSum = sum(p);
-            }
-        }
-    }
-
-    if (debug)
-    {
-        meshTools::writeOBJ(str(), p[0]);
-        vertI++;
-        str()<< "l " << vertI-1 << ' ' << vertI << nl;
-    }
-
-    // Failure to converge. Return best guess so far.
-    label ilo = findMin(y);
-    Swap(p[0], p[ilo]);
-    Swap(y[0], y[ilo]);
-    return false;
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::triSurfaceMeshes::triSurfaceMeshes
-(
-    const IOobject& io,
-    const fileNameList& names
-)
-:
-    PtrList<triSurfaceMesh>(names.size()),
-    allSurfaces_(identity(names.size()))
-{
-    forAll(names, i)
-    {
-        autoPtr<IOobject> surfaceIO = io.clone();
-        surfaceIO().rename(names[i]);
-
-        Info<< "Loading surface " << surfaceIO().name() << endl;
-
-        //fileName fullPath = surfaceIO().filePath();
-        //
-        //if (fullPath.size() == 0)
-        //{
-        //    FatalErrorIn
-        //    (
-        //        "triSurfaceMeshes::triSurfaceMeshes"
-        //        "(const IOobject&, const fileNameList&)"
-        //    )   << "Cannot load surface " << surfaceIO().name()
-        //        << " starting from path " << surfaceIO().path()
-        //        << exit(FatalError);
-        //}
-
-        set(i, new triSurfaceMesh(surfaceIO()));
-
-        if (Pstream::master())
-        {
-            string oldPrefix(Pout.prefix());
-            Pout.prefix() += "    ";
-            operator[](i).writeStats(Pout);
-            Pout.prefix() = oldPrefix;
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::fileNameList Foam::triSurfaceMeshes::allNames(const IOobject& io)
-{
-    return readDir(io.path(), fileName::FILE);
-}
-
-
-Foam::fileNameList Foam::triSurfaceMeshes::names() const
-{
-    fileNameList surfNames(size());
-
-    forAll(surfNames, surfI)
-    {
-        surfNames[surfI] = operator[](surfI).IOobject::name();
-    }
-    return surfNames;
-}
-
-
-// Find any intersection
-Foam::label Foam::triSurfaceMeshes::findAnyIntersection
-(
-    const labelList& surfaces,
-    const point& start,
-    const point& end,
-    pointIndexHit& hitInfo
-) const
-{
-    forAll(surfaces, i)
-    {
-        label surfI = surfaces[i];
-
-        hitInfo = operator[](surfI).findLineAny(start, end);
-
-        if (hitInfo.hit())
-        {
-            return surfI;
-        }
-    }
-    return -1;
-}
-
-
-Foam::label Foam::triSurfaceMeshes::findAnyIntersection
-(
-    const point& start,
-    const point& end,
-    pointIndexHit& hitInfo
-) const
-{
-    return findAnyIntersection
-    (
-        allSurfaces_,
-        start,
-        end,
-        hitInfo
-    );
-}
-
-
-// Find intersections of edge nearest to both endpoints.
-void Foam::triSurfaceMeshes::findAllIntersections
-(
-    const labelList& surfaces,
-    const point& start,
-    const point& end,
-
-    labelList& surfacesIndex,
-    List<pointIndexHit>& surfaceHitInfo
-) const
-{
-    DynamicList<label> hitSurfaces(surfaces.size());
-    DynamicList<pointIndexHit> hitInfos(surfaces.size());
-    DynamicList<scalar> hitDistSqr(surfaces.size());
-
-    const vector dirVec(end-start);
-    const scalar magSqrDirVec(magSqr(dirVec));
-    const vector smallVec(Foam::sqrt(SMALL)*dirVec);
-
-    forAll(surfaces, i)
-    {
-        label surfI = surfaces[i];
-
-        // Current starting point of ray.
-        point pt = start;
-
-        while (true)
-        {
-            // See if any intersection between pt and end
-            pointIndexHit inter = operator[](surfI).findLine(pt, end);
-
-            if (!inter.hit())
-            {
-                break;
-            }
-            hitSurfaces.append(surfI);
-            hitInfos.append(inter);
-            hitDistSqr.append(magSqr(inter.hitPoint() - start));
-
-            pt = inter.hitPoint() + smallVec;
-
-            if (((pt-start)&dirVec) > magSqrDirVec)
-            {
-                // Adding smallVec has taken us beyond end
-                break;
-            }
-        }
-    }
-    surfacesIndex.setSize(hitSurfaces.size());
-    surfaceHitInfo.setSize(hitSurfaces.size());
-
-    if (hitSurfaces.size() > 0)
-    {
-        // Sort and transfer to arguments
-
-        hitSurfaces.shrink();
-        hitInfos.shrink();
-        hitDistSqr.shrink();
-
-        // Sort from start to end.
-        SortableList<scalar> sortedDist(hitDistSqr);
-
-        forAll(sortedDist.indices(), newPos)
-        {
-            label oldPos = sortedDist.indices()[newPos];
-            surfacesIndex[newPos] = hitSurfaces[oldPos];
-            surfaceHitInfo[newPos] = hitInfos[oldPos];
-        }
-    }
-}
-
-
-void Foam::triSurfaceMeshes::findAllIntersections
-(
-    const point& start,
-    const point& end,
-
-    labelList& surfacesIndex,
-    List<pointIndexHit>& surfaceHitInfo
-) const
-{
-    findAllIntersections
-    (
-        allSurfaces_,
-        start,
-        end,
-        surfacesIndex,
-        surfaceHitInfo
-    );
-}
-
-
-// Find intersections of edge nearest to both endpoints.
-void Foam::triSurfaceMeshes::findNearestIntersection
-(
-    const labelList& surfaces,
-    const point& start,
-    const point& end,
-
-    label& surface1,
-    pointIndexHit& hit1,
-    label& surface2,
-    pointIndexHit& hit2
-) const
-{
-    surface1 = -1;
-    // Initialize to endpoint
-    hit1 = pointIndexHit(false, end, -1);
-
-    forAll(surfaces, i)
-    {
-        label surfI = surfaces[i];
-
-        if (hit1.rawPoint() == start)
-        {
-            break;
-        }
-
-        // See if any intersection between start and current nearest
-        pointIndexHit inter = operator[](surfI).findLine
-        (
-            start,
-            hit1.rawPoint()
-        );
-
-        if (inter.hit())
-        {
-            hit1 = inter;
-            surface1 = surfI;
-        }
-    }
-
-
-    // Find the nearest intersection from end to start. Note that we initialize
-    // to the first intersection (if any).
-    surface2 = surface1;
-    hit2 = pointIndexHit(hit1);
-
-    if (hit1.hit())
-    {
-        // Test from the end side.
-        forAll(surfaces, i)
-        {
-            label surfI = surfaces[i];
-
-            if (hit2.rawPoint() == end)
-            {
-                break;
-            }
-
-            // See if any intersection between end and current nearest
-            pointIndexHit inter = operator[](surfI).findLine
-            (
-                end,
-                hit2.rawPoint()
-            );
-
-            if (inter.hit())
-            {
-                hit2 = inter;
-                surface2 = surfI;
-            }
-        }
-    }
-}
-
-
-void Foam::triSurfaceMeshes::findNearestIntersection
-(
-    const point& start,
-    const point& end,
-
-    label& surface1,
-    pointIndexHit& hit1,
-    label& surface2,
-    pointIndexHit& hit2
-) const
-{
-    findNearestIntersection
-    (
-        allSurfaces_,
-        start,
-        end,
-        surface1,
-        hit1,
-        surface2,
-        hit2
-    );
-}
-
-
-// Find nearest. Return -1 or nearest point
-Foam::label Foam::triSurfaceMeshes::findNearest
-(
-    const labelList& surfaces,
-    const point& pt,
-    const scalar nearestDistSqr,
-    pointIndexHit& nearestHit
-) const
-{
-    // nearest surface
-    label minSurface = -1;
-    scalar minDistSqr = Foam::sqr(GREAT);
-
-    forAll(surfaces, i)
-    {
-        label surfI = surfaces[i];
-
-        pointIndexHit hit
-        (
-            operator[](surfI).findNearest(pt, nearestDistSqr)
-        );
-
-        if (hit.hit())
-        {
-            scalar distSqr = magSqr(hit.hitPoint()-pt);
-
-            if (distSqr < minDistSqr)
-            {
-                minDistSqr = distSqr;
-                minSurface = surfI;
-                nearestHit = hit;
-            }
-        }
-    }
-
-    if (minSurface == -1)
-    {
-        // maxLevel unchanged. No interesting surface hit.
-        nearestHit.setMiss();
-    }
-
-    return minSurface;
-}
-
-
-// Find nearest. Return -1 or nearest point
-Foam::label Foam::triSurfaceMeshes::findNearest
-(
-    const point& pt,
-    const scalar nearestDistSqr,
-    pointIndexHit& nearestHit
-) const
-{
-    return findNearest
-    (
-        allSurfaces_,
-        pt,
-        nearestDistSqr,
-        nearestHit
-    );
-}
-
-
-Foam::label Foam::triSurfaceMeshes::findNearestAndClassify
-(
-    const labelList& surfacesToTest,
-    const point& pt,
-    const scalar nearestDistSqr,
-    surfaceLocation& nearest
-) const
-{
-    pointIndexHit nearestInfo;
-    label surfI = findNearest
-    (
-        surfacesToTest,
-        pt,
-        nearestDistSqr,
-        nearestInfo
-    );
-
-    if (surfI != -1)
-    {
-        nearest = triSurfaceTools::classify
-        (
-            operator[](surfI),
-            nearestInfo.index(),        // triangle
-            nearestInfo.rawPoint()      // point on edge/inside triangle
-        );
-    }
-
-    return surfI;
-}
-
-
-//- Calculate point which is on a set of surfaces.
-Foam::surfaceLocation Foam::triSurfaceMeshes::facesIntersectionTrack
-(
-    const labelList& surfacesToTest,
-    const scalar initialDistSqr,
-    const scalar convergenceDistSqr,
-    const point& start
-) const
-{
-    autoPtr<OFstream> str;
-    label vertI = 0;
-
-    if (debug)
-    {
-        str.reset(new OFstream("track.obj"));
-    }
-
-    surfaceLocation current
-    (
-        pointIndexHit
-        (
-            false,
-            start,
-            -1
-        ),
-        triPointRef::NONE,
-        -1
-    );
-
-    // Dump start point
-    if (str.valid())
-    {
-        Pout<< "Starting at " << current.info()
-            << " written as point " << vertI
-            << endl;
-        meshTools::writeOBJ(str(), current.rawPoint());
-        vertI++;
-    }
-
-    // Now slide current along all faces until it settles
-    label iter = 0;
-
-    const label maxIter = 10;
-
-    for (; iter < maxIter; iter++)
-    {
-        // - store old position
-        // - slide it along all faces
-        // - if it hasn't changed position exit loop
-
-        if (debug)
-        {
-            Pout<< endl
-                << "Iteration " << iter << endl
-                << "-----------" << endl;
-        }
-
-        point oldCurrent = current.rawPoint();
-
-        forAll(surfacesToTest, i)
-        {
-            label surfI = surfacesToTest[i];
-
-            // Project pt onto surf
-            // ~~~~~~~~~~~~~~~~~~~~
-            point copy(current.rawPoint()); // need to work on copy
-            if
-            (
-                findNearestAndClassify
-                (
-                    labelList(1, surfI),
-                    copy,
-                    initialDistSqr,             // initialDistSqr
-                    current
-                )
-             == -1
-            )
-            {
-                FatalErrorIn("triSurfaceMeshes::facesIntersectionTrack(..)")
-                    << "Did not find a point on surface " << surfI
-                    << " which is within sqrt(" << initialDistSqr
-                    << ") of " << copy
-                    << abort(FatalError);
-            }
-
-
-            if (debug)
-            {
-                Pout<< "Nearest onto surface " << surfI
-                    << ' ' << operator[](surfI).IOobject::name() << " : "
-                    << current.info() << " written as point " << vertI
-                    << endl;
-            }
-
-            // Dump current
-            if (str.valid())
-            {
-                meshTools::writeOBJ(str(), current.rawPoint());
-                vertI++;
-                str()<< "l " << vertI-1 << ' ' << vertI << nl;
-            }
-
-            // Find corresponding point on next surface
-            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-            label nextSurfI = surfacesToTest[surfacesToTest.fcIndex(i)];
-
-            surfaceLocation next;
-            findNearestAndClassify
-            (
-                labelList(1, nextSurfI),
-                point(current.rawPoint()),
-                initialDistSqr,                 // initialDistSqr
-                next
-            );
-
-            // Since next is on a different surface we cannot compare
-            // indices (like in snapToEnd) so make sure this does not
-            // happen.
-            next.elementType() = triPointRef::NONE;
-            next.setIndex(-123);
-
-            if (debug)
-            {
-                Pout<< "Nearest onto next surface " << nextSurfI
-                    << ' ' << operator[](nextSurfI).IOobject::name() << " : "
-                    << next.info() << endl;
-            }
-
-            if
-            (
-                magSqr(current.rawPoint() - next.rawPoint())
-              > convergenceDistSqr
-            )
-            {
-                // Track from current to next
-                // ~~~~~~~~~~~~~~~~~~~~~~~~~~
-                //vector n = current.normal(surfaces[surfI]);
-
-                current = triSurfaceTools::trackToEdge
-                (
-                    operator[](surfI),
-                    current,
-                    next,
-                    plane(start, current.rawPoint(), next.rawPoint())
-                );
-
-                if (debug)
-                {
-                    Pout<< "Sliding along surface "
-                        << surfI << ' ' << operator[](surfI).IOobject::name()
-                        << " in direction of "
-                        << nextSurfI << ' '
-                        << operator[](nextSurfI).IOobject::name()
-                        << " stopped at " << current.info()
-                        << " written as point " << vertI << endl;
-                }
-                if (str.valid())
-                {
-                    meshTools::writeOBJ(str(), current.rawPoint());
-                    vertI++;
-                    str()<< "l " << vertI-1 << ' ' << vertI << nl;
-                }
-            }
-        }
-
-        scalar distSqr = magSqr(oldCurrent - current.rawPoint());
-
-        if (debug)
-        {
-            Pout<< "distSqr:" << distSqr
-                << " convergenceDistSqr:" << convergenceDistSqr << endl;
-        }
-
-        if (distSqr < convergenceDistSqr)
-        {
-            break;
-        }
-    }
-
-    if (iter == maxIter)
-    {
-        FatalErrorIn("triSurfaceMeshes::facesIntersectionTrack(..)")
-            << "Did not converge in " << iter
-            << " iterations to find a point which is on surfaces "
-            << IndirectList<fileName>(names(), surfacesToTest)() << nl
-            << "Start point:" << start << nl
-            << "Current nearest:" << current.info() << nl
-            << "Please check that your surfaces actually intersect and"
-            << " that the starting point is close to the intersection point."
-            << abort(FatalError);
-    }
-
-    return current;
-}
-
-
-//- Calculate point which is on a set of surfaces.
-Foam::pointIndexHit Foam::triSurfaceMeshes::facesIntersection
-(
-    const labelList& surfacesToTest,
-    const scalar initDistSqr,
-    const scalar convergenceDistSqr,
-    const point& start
-) const
-{
-    // Get four starting points. Take these as the projection of the
-    // starting point onto the surfaces and the mid point
-    List<point> nearest(surfacesToTest.size()+1);
-
-    point sumNearest = vector::zero;
-
-    forAll(surfacesToTest, i)
-    {
-        label surfI = surfacesToTest[i];
-
-        pointIndexHit hit
-        (
-            operator[](surfI).findNearest(start, initDistSqr)
-        );
-
-        if (hit.hit())
-        {
-            nearest[i] = hit.hitPoint();
-            sumNearest += nearest[i];
-        }
-        else
-        {
-            FatalErrorIn
-            (
-                "triSurfaceMeshes::facesIntersection"
-                "(const labelList&, const scalar, const scalar, const point&)"
-            )   << "Did not find point within distance "
-                << initDistSqr << " of starting point " << start
-                << " on surface " << operator[](surfI).IOobject::name()
-                << abort(FatalError);
-        }
-    }
-
-    nearest[nearest.size()-1] = sumNearest / surfacesToTest.size();
-
-
-    // Get the sum of distances (initial evaluation)
-    List<scalar> nearestDist(nearest.size());
-
-    forAll(nearestDist, i)
-    {
-        nearestDist[i] = sumDistSqr(surfacesToTest, initDistSqr, nearest[i]);
-    }
-
-
-    //- Downhill Simplex method
-
-    bool converged = morphTet
-    (
-        surfacesToTest,
-        initDistSqr,
-        convergenceDistSqr,
-        2000,
-        nearest,
-        nearestDist
-    );
-
-
-    pointIndexHit intersection;
-
-    if (converged)
-    {
-        // Project nearest onto 0th surface.
-        intersection = operator[](surfacesToTest[0]).findNearest
-        (
-            nearest[0],
-            nearestDist[0]
-        );
-    }
-
-    //if (!intersection.hit())
-    //{
-    //    // Restart
-    //    scalar smallDist = Foam::sqr(convergenceDistSqr);
-    //    nearest[0] = intersection.hitPoint();
-    //    nearest[1] = nearest[0];
-    //    nearest[1].x() += smallDist;
-    //    nearest[2] = nearest[0];
-    //    nearest[2].y() += smallDist;
-    //    nearest[3] = nearest[0];
-    //    nearest[3].z() += smallDist;
-    //
-    //    forAll(nearestDist, i)
-    //    {
-    //        nearestDist[i] = sumDistSqr
-    //        (
-    //            surfacesToTest,
-    //            initDistSqr,
-    //            nearest[i]
-    //        );
-    //    }
-    //
-    //    intersection = morphTet
-    //    (
-    //        surfacesToTest,
-    //        initDistSqr,
-    //        convergenceDistSqr,
-    //        1000,
-    //        nearest,
-    //        nearestDist
-    //    );
-    //}
-
-    return intersection;
-}
-
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.H b/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.H
deleted file mode 100644
index 4269dba6a7..0000000000
--- a/src/meshTools/triSurface/triSurfaceMeshes/triSurfaceMeshes.H
+++ /dev/null
@@ -1,261 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software; you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation; either version 2 of the License, or (at your
-    option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM; if not, write to the Free Software Foundation,
-    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-Class
-    Foam::triSurfaceMeshes
-
-Description
-    Container for triSurfaces read from files.
-
-SourceFiles
-    triSurfaceMeshes.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef triSurfaceMeshes_H
-#define triSurfaceMeshes_H
-
-#include "triSurfaceMesh.H"
-#include "fileNameList.H"
-#include "treeDataTriSurface.H"
-#include "indexedOctree.H"
-#include "surfaceLocation.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class plane;
-
-/*---------------------------------------------------------------------------*\
-                           Class triSurfaceMeshes Declaration
-\*---------------------------------------------------------------------------*/
-
-class triSurfaceMeshes
-:
-    public PtrList<triSurfaceMesh>
-{
-    // Private data
-
-        //- Indices of all surfaces. Precalculated and stored.
-        const labelList allSurfaces_;
-
-
-    // Private Member Functions
-
-        //- Calculate sum of distances to nearest point on surfaces. Is used
-        //  in minimisation to find intersection. Returns sum of (square of)
-        // distances to the surfaces.
-        scalar sumDistSqr
-        (
-            const labelList& surfacesToTest,
-            const scalar initialDistSqr,    // search box
-            const point& pt
-        ) const;
-
-        //- Takes the tet (points p) and reflects the point with the
-        //  highest value around the centre (pSum). Checks if it gets closer
-        //  and updates p, y if so.
-        scalar tryMorphTet
-        (
-            const labelList& surfacesToTest,
-            const scalar initialDistSqr,
-            List<vector>& p,
-            List<scalar>& y,
-            vector& pSum,
-            const label ihi,
-            const scalar fac
-        ) const;
-
-        //- Downhill simplex method: find the point with min cumulative
-        //  distance to all surfaces. Does so by morphing a tet (points p).
-        //  Returns the point on the 0th surface or hit if not reached within
-        //  maxIters iterations.
-        bool morphTet
-        (
-            const labelList& surfacesToTest,
-            const scalar initialDistSqr,
-            const scalar convergenceDistSqr,
-            const label maxIter,
-            List<vector>& p,
-            List<scalar>& y
-        ) const;
-
-        //- Disallow default bitwise copy construct
-        triSurfaceMeshes(const triSurfaceMeshes&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const triSurfaceMeshes&);
-
-
-public:
-
-    ClassName("triSurfaceMeshes");
-
-    // Constructors
-
-        //- Construct from directory (io.instance()) and list of local filenames
-        triSurfaceMeshes(const IOobject& io, const fileNameList&);
-
-
-    // Member Functions
-
-        //- Get all surfaces in directory
-        static fileNameList allNames(const IOobject&);
-
-        //- Get names of surfaces
-        fileNameList names() const;
-
-
-        //- Find any intersection. Return hit point information and surface
-        //  number
-        label findAnyIntersection
-        (
-            const labelList& surfacesToTest,
-            const point& start,
-            const point& end,
-            pointIndexHit&
-        ) const;
-
-        label findAnyIntersection
-        (
-            const point& start,
-            const point& end,
-            pointIndexHit&
-        ) const;
-
-
-        //- Find all intersections in order from start to end. Returns for
-        //  every hit the surface and the hit info.
-        void findAllIntersections
-        (
-            const labelList& surfacesToTest,
-            const point& start,
-            const point& end,
-            labelList& surfaces,
-            List<pointIndexHit>& surfaceHits
-        ) const;
-
-        void findAllIntersections
-        (
-            const point& start,
-            const point& end,
-            labelList& surfaces,
-            List<pointIndexHit>& surfaceHits
-        ) const;
-
-
-        //- Find intersections of edge nearest to both endpoints.
-        void findNearestIntersection
-        (
-            const labelList& surfacesToTest,
-            const point& start,
-            const point& end,
-
-            label& surface1,        // surface index
-            pointIndexHit& hit1,    // hit point information
-            label& surface2,
-            pointIndexHit& hit2
-        ) const;
-
-        void findNearestIntersection
-        (
-            const point& start,
-            const point& end,
-
-            label& surface1,        // surface index
-            pointIndexHit& hit1,    // hit point information
-            label& surface2,
-            pointIndexHit& hit2
-        ) const;
-
-
-        //- Find nearest. Return -1 (and a miss()) or surface and nearest point.
-        label findNearest
-        (
-            const labelList& surfacesToTest,
-            const point&,
-            const scalar nearestDistSqr,
-            pointIndexHit&
-        ) const;
-
-        label findNearest
-        (
-            const point&,
-            const scalar nearestDistSqr,
-            pointIndexHit&
-        ) const;
-
-
-        //- Find nearest point (like findNearest) but also return whether
-        //  point is on edge or on point. Returns -1 if not found
-        //  (within nearestDistSqr) on any of the surfaces.
-        //  Returns surfaceLocation
-        //  - hit : nearest point is inside triangle
-        //  - elementType : none, edge  or point
-        //  - index       : triI, edgeI or localPointI
-        label findNearestAndClassify
-        (
-            const labelList& surfacesToTest,
-            const point& pt,
-            const scalar nearestDistSqr,
-            surfaceLocation& nearest
-        ) const;
-
-        //- Calculate point which is on a set of surfaces. Takes
-        //  - initialDistSqr : search dimensions to find point on surface
-        //  - convergenceDistSqr : when point is converged
-        // Will bomb out if no stable point reached after certain number
-        // of iterations.
-        surfaceLocation facesIntersectionTrack
-        (
-            const labelList& surfacesToTest,
-            const scalar initialDistSqr,
-            const scalar convergenceDistSqr,
-            const point& start
-        ) const;
-
-        //- Calculate point which is on a set of surfaces.
-        pointIndexHit facesIntersection
-        (
-            const labelList& surfacesToTest,
-            const scalar initialDistSqr,
-            const scalar convergenceDistSqr,
-            const point& start
-        ) const;
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

From ffe2142dee638a52d45f5e574c8bc78782d12571 Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Mon, 7 Jul 2008 19:50:53 +0100
Subject: [PATCH 04/12] refining without surfaces

---
 .../autoHexMesh/meshRefinement/meshRefinementBaffles.C      | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
index c9c2d14c13..a92f61a78a 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -1838,7 +1838,11 @@ Foam::autoPtr<Foam::mapPolyMesh>  Foam::meshRefinement::splitMesh
     const labelList& faceNeighbour = mesh_.faceNeighbour();
 
     // Patch for exposed faces for lack of anything sensible.
-    const label defaultPatch = globalToPatch[0];
+    label defaultPatch = 0;
+    if (globalToPatch.size() > 0)
+    {
+        defaultPatch = globalToPatch[0];
+    }
 
     for (label i = 0; i < nBufferLayers; i++)
     {

From ab17085c1a9943114dc293e7fdbde51bdac5f695 Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Mon, 7 Jul 2008 19:51:20 +0100
Subject: [PATCH 05/12] adapted to new syntax

---
 .../generation/snappyHexMesh/snappyHexMesh.C   | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
index bd655dc251..e53f8f68d3 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
@@ -76,16 +76,19 @@ int main(int argc, char *argv[])
     );
 
     // refinement parameters
-    const dictionary& refineDict = meshDict.subDict("refineDict");
+    const dictionary& refineDict = meshDict.subDict("castellatedMeshControls");
+
+    // all surface geometry
+    const dictionary& geometryDict = meshDict.subDict("geometry");
 
     // snap-to-surface parameters
-    const dictionary& snapDict = meshDict.subDict("snapDict");
+    const dictionary& snapDict = meshDict.subDict("snapControls");
 
     // mesh motion and mesh quality parameters
-    const dictionary& motionDict = meshDict.subDict("motionDict");
+    const dictionary& motionDict = meshDict.subDict("meshQualityControls");
 
     // layer addition parameters
-    const dictionary& layerDict = meshDict.subDict("layerDict");
+    const dictionary& layerDict = meshDict.subDict("addLayersControls");
 
 
     // Main meshing driver. Read surfaces. Determine initial intersections.
@@ -93,13 +96,14 @@ int main(int argc, char *argv[])
     (
         mesh,
         meshDict,       // global control parameters
+        geometryDict,
         refineDict,     // refinement parameters
         decomposeDict
     );
 
-    Switch wantRefine(meshDict.lookup("doRefine"));
-    Switch wantSnap(meshDict.lookup("doSnap"));
-    Switch wantLayers(meshDict.lookup("doLayers"));
+    Switch wantRefine(meshDict.lookup("castellatedMesh"));
+    Switch wantSnap(meshDict.lookup("snap"));
+    Switch wantLayers(meshDict.lookup("addLayers"));
 
     if (wantRefine)
     {

From 72fb77ccce4a219676301934305ba93b0c8707ee Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Tue, 8 Jul 2008 12:07:54 +0100
Subject: [PATCH 06/12] updated sample dictionary

---
 .../snappyHexMesh/snappyHexMeshDict           | 338 ++++++++++--------
 1 file changed, 187 insertions(+), 151 deletions(-)

diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
index e9aa8f189d..4e71557fdb 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
@@ -22,161 +22,171 @@ FoamFile
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-// Which phases to run.
-doRefine true;
-doSnap   true;
-doLayers true; // includes autoMergeFaces
+// Which of the steps to run
+castellatedMesh true;
+snap            true;
+addLayers       false;
 
 
-// Whether to dump intermediate meshes and print lots
-// 1 : write mesh
-// 2 : write volScalarField with cellLevel for postprocessing
-// 4 : write current intersections as .obj files
-debug 0;
-
-refineDict
+// Geometry. Definition of all surfaces. All surfaces are of class
+// searchableSurface.
+// Surfaces are used
+// - to specify refinement for any mesh cell intersecting it
+// - to specify refinement for any mesh cell inside/outside/near
+// - to 'snap' the mesh boundary to the surface
+geometry
 {
-    // Which part to keep.
-    // NOTE: This point should never be on a face, always inside a cell, even
-    // after refinement.
-    keepPoints ((3 0.28 0.43));
+//    box1x1x1
+//    {
+//        type searchableBox;
+//        min (1.5 1 -0.5);
+//        max (3.5 2 0.5);
+//    }
+//
+//    sphere.stl
+//    {
+//        type triSurfaceMesh;
+//
+//        // Per region the patchname. If not provided will be <name>_<region>.
+//        regions
+//        {
+//            secondSolid
+//            {
+//                name mySecondPatch;
+//            }
+//        }
+//    }
 
-    // Whether to remove/split cells likely to give problems when snapping
-    handleSnapProblems on;
+    sphere2
+    {
+        type searchableSphere;
+        centre  (1.5 1.5 1.5);
+        radius  1.03;
+    }
+};
 
-    // Merge tolerance. Is fraction of overall bounding box of initial mesh
-    mergeTolerance 1E-6;
+
+
+// Settings for the castellatedMesh generation.
+castellatedMeshControls
+{
+
+    // Refinement parameters
+    // ~~~~~~~~~~~~~~~~~~~~~
 
     // While refining maximum number of cells per processor. This is basically
     // the number of cells that fit on a processor. If you choose this too small
     // it will do just more refinement iterations to obtain a similar mesh.
-    procCellLimit 1000000;
-
+    maxLocalCells 1000000;
 
     // Overall cell limit (approximately). Refinement will stop immediately
     // upon reaching this number so a refinement level might not complete.
     // Note that this is the number of cells before removing the part which
-    // is not 'visible' from the keepPoint. The final number of cells might actually
-    // be a lot less.
-    cellLimit 2000000;
-
+    // is not 'visible' from the keepPoint. The final number of cells might
+    // actually be a lot less.
+    maxGlobalCells 2000000;
 
     // The surface refinement loop might spend lots of iterations refining just a
     // few cells. This setting will cause refinement to stop if <= minimumRefine
     // are selected for refinement. Note: it will at least do one iteration
     // (unless the number of cells to refine is 0)
-    minimumRefine 0;
-
-
-
+    minRefinementCells 0;
 
     // Number of buffer layers between different levels.
     // 1 means normal 2:1 refinement restriction, larger means slower
     // refinement.
-    nBufferLayers 1;
+    nCellsBetweenLevels 1;
 
 
-    // Feature Edge Refinement
-    // ~~~~~~~~~~~~~~~~~~~~~~~
 
-    // External feature file. Read from constant/triSurface for now.
-    // Limitations:
-    // - either start or edge of any feature line has to be inside domain
-    //   and be visible from keepPoint on starting mesh.
-    // - refining cells containing features is separate phase before refining
-    //   based on surface.
-    // - no load balancing, no check for cellLimit is done while doing this.
+    // Explicit feature edge refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Specifies a level for any cell intersected by its edges.
+    // This is a featureEdgeMesh, read from constant/triSurface for now.
     features
     (
-    //    {
-    //        file "someLine.eMesh";
-    //        level 2;
-    //    }
+        //{
+        //    file "someLine.eMesh";
+        //    level 2;
+        //}
     );
 
 
-    // Internal Mesh Refinement
-    // ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    // Specifies the areas where the refinement has to be a certain level.
-    // These surfaces have to be closed. Refinement is either inside
-    // (refineInside = true) or outside. (note:insideness or outsideness
-    // is with respect to far away)
-    // Note:that even using these the transition can never be faster than
-    // nBufferLayers!
-    // Note:the refinement level can never be higher than any of the surfaces
-    // they overlap with. See below for the surface refinement level specification.
-    refinementShells
-    (
-        {
-            //type triSurfaceMesh;
-            //name cube1x1x1.stl;
-            type searchableBox;
-            name box1x1x1;
-            min (2.5 -0.5 -0.5);
-            max (3.5 0.5 0.5);
-
-            level 4;
-            refineInside true;
-        }
-    );
-
 
     // Surface based refinement
     // ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    // Curvature. Cosine of angle between two neighbouring surface intersections.
-    // Only used if cell level > minLevel and < maxLevel.
-    curvature 0.5;
+    // Specifies two levels for every surface. The first is the minimum level,
+    // every cell intersecting a surface gets refined up to the minimum level.
+    // The second level is the maximum level. Cells that 'see' multiple
+    // intersections where the intersections make an
+    // angle > resolveFeatureAngle get refined up to the maximum level.
 
-
-    // Overall the refinement is according to the following rules:
-    // - if the cell-cell vector intersects a surface any cell that
-    //   is less refined than the minRefinementLevel of the surface gets refined.
-    // - else if the refinement level of the cell is between the
-    //   minRefinementLevel and maxRefinementLevel the cell gets refined if
-    //      - the normal of neighbouring surface intersections differ by more
-    //        than above curvature
-    //      - or if neighbouring surface intersections are on different surfaces or
-    //        different surface regions.
-
-
-    // surfaces
-    surfaces
-    (
+    refinementSurfaces
+    {
+        sphere.stl
         {
-            name    sphere;
-            file    "sphere.stl";
-
-            // Surface wide refinement level
-            minRefinementLevel 1;
-            maxRefinementLevel 1;
-
-            // Layers
-            surfaceLayers 1;
-
-            // Region specific refinement level
+            // Surface-wise min and max refinement level
+            level (2 2);
+        
+            // Optional region-wise level specification
             regions
-            (
+            {
+                secondSolid
                 {
-                    name firstSolid;
-                    minRefinementLevel 3;
-                    maxRefinementLevel 3;
-                    surfaceLayers 2;
+                    level (3 3);
                 }
-                {
-                    name secondSolid;
-                    minRefinementLevel 1;
-                    maxRefinementLevel 1;
-                    surfaceLayers 1;
-                }
-            );
+            }
         }
-    );
+    }
+
+    resolveFeatureAngle 30;
+
+
+    // Region-wise refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~
+
+    // Specifies refinement level for cells in relation to a surface. One of
+    // three modes
+    // - distance. 'levels' specifies per distance to the surface the
+    //   wanted refinement level. The distances need to be specified in
+    //   descending order.
+    // - inside. 'levels' is only one entry and only the level is used. All
+    //   cells inside the surface get refined up to the level. The surface
+    //   needs to be closed for this to be possible.
+    // - outside. Same but cells outside.
+
+    refinementRegions
+    {
+        //box1x1x1
+        //{
+        //    mode inside;
+        //    levels ((1.0 4));
+        //}
+        //sphere.stl
+        //{
+        //    mode distance;
+        //    levels ((1.0 5) (2.0 3));
+        //}
+    }
+
+
+    // Mesh selection
+    // ~~~~~~~~~~~~~~
+
+    // After refinement patches get added for all refinementSurfaces and
+    // all cells intersecting the surfaces get put into these patches. The
+    // section reachable from the locationInMesh is kept.
+    // NOTE: This point should never be on a face, always inside a cell, even
+    // after refinement.
+    locationInMesh (5 0.28 0.43);
 }
 
-// For snapping
-snapDict
+
+
+// Settings for the snapping.
+snapControls
 {
     //- Number of patch smoothing iterations before finding correspondence
     //  to surface
@@ -185,47 +195,64 @@ snapDict
     //- Relative distance for points to be attracted by surface feature point
     //  or edge. True distance is this factor times local
     //  maximum edge length.
-    snapTol 4.0;
+    tolerance 4.0;
 
-    //- Whether to move internal mesh as well as boundary
-    smoothMesh true;
-
-    //- Number of mesh displacement smoothing iterations.
-    nSmoothDispl 30;
+    //- Number of mesh displacement relaxation iterations.
+    nSolveIter 30;
 
     //- Maximum number of snapping relaxation iterations. Should stop
     //  before upon reaching a correct mesh.
-    nSnap 5;
+    nRelaxIter 5;
 }
 
 
-// For cell layers
-layerDict
+
+// Settings for the layer addition.
+addLayersControls
 {
+    // Per final patch (so not geometry!) the layer information
+    layers
+    {
+        sphere.stl_firstSolid
+        {
+            nSurfaceLayers 1;
+
+        }
+        maxY
+        {
+            nSurfaceLayers 1;
+        }
+    }
+
+    // Expansion factor for layer mesh
+    expansionRatio 1.0;
+
+    //- Wanted thickness of final added cell layer. If multiple layers
+    //  is the
+    //  thickness of the layer furthest away from the wall.
+    //  Relative to undistorted size of cell outside layer.
+    finalLayerRatio 0.3; 
+
+    //- Minimum thickness of cell layer. If for any reason layer
+    //  cannot be above minThickness do not add layer.
+    //  Relative to undistorted size of cell outside layer.
+    minThickness 0.25;
+
+    //- If points get not extruded do nGrow layers of connected faces that are
+    //  also not grown. This helps convergence of the layer addition process
+    //  close to features.
+    nGrow 1;
+
+
+    // Advanced settings
+
     //- When not to extrude surface. 0 is flat surface, 90 is when two faces
     //  make straight angle.
     featureAngle 60;
 
     //- Maximum number of snapping relaxation iterations. Should stop
     //  before upon reaching a correct mesh.
-    nSnap 5;
-
-
-    //- Minimum thickness of cell layer. If for any reason layer cannot be
-    //  above minThickness do not add layer if thickness below minThickNess.
-    //  Relative to undistorted cell size
-    minThickness 0.25;
-
-    //- If points get not extruded do nGrow layers of connected faces that are
-    //  not grown. Is used to not do layers at all close to features.
-    nGrow 1;
-
-    // Expansion factor for layer mesh
-    expansionRatio 1.3;	
-
-    // Ratio of cell size in final added cell layer to cell size 
-    // outside layer 
-    finalLayerRatio 0.3;
+    nRelaxIter 5;
 
     // Number of smoothing iterations of surface normals 
     nSmoothSurfaceNormals 1;
@@ -248,20 +275,14 @@ layerDict
 
     // Create buffer region for new layer terminations
     nBufferCellsNoExtrude 0;
-
-    thickness 0.5;
-    nSmoothDispl 4;
 }
 
 
-// For mesh motion
-motionDict
-{
-    //
-    // Mesh Quality Parameters. Decide when mesh is good enough to stop
-    // smoothing.
-    //
 
+// Generic mesh quality settings. At any undoable phase these determine
+// where to undo.
+meshQualityControls
+{
     //- Maximum non-orthogonality allowed. Set to 180 to disable.
     maxNonOrtho 65;
 
@@ -298,10 +319,10 @@ motionDict
     //- minVolRatio (0 -> 1)
     minVolRatio 0.01;
 
-
     //must be >0 for Fluent compatibility
     minTriangleTwist -1;
 
+
     // Advanced
 
     //- Number of error distribution iterations
@@ -311,4 +332,19 @@ motionDict
 }
 
 
+// Advanced
+
+// Flags for optional output
+// 0 : only write final meshes
+// 1 : write intermediate meshes
+// 2 : write volScalarField with cellLevel for postprocessing
+// 4 : write current intersections as .obj files
+debug 0;
+
+
+// Merge tolerance. Is fraction of overall bounding box of initial mesh.
+// Note: the write tolerance needs to be higher than this.
+mergeTolerance 1E-6;
+
+
 // ************************************************************************* //

From 4a68c38ec4e173389ecdae1830a358ad468cccfc Mon Sep 17 00:00:00 2001
From: henry <Henry Weller h.weller@opencfd.co.uk>
Date: Tue, 8 Jul 2008 16:25:00 +0100
Subject: [PATCH 07/12] Added new constructor from fileName to
 interpolationTable and removed the objectRegistry argument from the
 constructor from dictionary.  Now case-relative paths should be specified
 using $FOAM_CASE.

---
 .../interpolationTable/interpolationTable.C   | 76 +++++++++---------
 .../interpolationTable/interpolationTable.H   | 77 ++++++++-----------
 ...gFlowRateInletVelocityFvPatchVectorField.C | 24 ++----
 ...timeVaryingUniformFixedValueFvPatchField.C |  3 +-
 ...ngUniformTotalPressureFvPatchScalarField.C |  6 +-
 5 files changed, 83 insertions(+), 103 deletions(-)

diff --git a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
index e2f1f92e77..bfb0ce9f12 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
+++ b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
@@ -26,40 +26,14 @@ License
 
 #include "interpolationTable.H"
 #include "IFstream.H"
-#include "objectRegistry.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
 
 template<class Type>
-Foam::interpolationTable<Type>::interpolationTable()
-:
-    List<Tuple2<scalar, Type> >(),
-    dict_(dictionary::null),
-    boundAction_(interpolationTable::WARN),
-    fileName_("undefined_fileName")
-{}
-
-
-template<class Type>
-Foam::interpolationTable<Type>::interpolationTable
-(
-    const objectRegistry& obr,
-    const dictionary& dict
-)
-:
-    List<Tuple2<scalar, Type> >(),
-    dict_(dict),
-    boundAction_(wordToBoundAction(dict.lookup("boundAction"))),
-    fileName_(dict.lookup("fileName"))
+void Foam::interpolationTable<Type>::readTable()
 {
     fileName_.expand();
 
-    // Correct for relative path
-    if (fileName_[0] != '/')
-    {
-        fileName_ = obr.db().path()/fileName_;
-    }
-
     // Read data from file
     IFstream(fileName_)() >> *this;
 
@@ -78,6 +52,39 @@ Foam::interpolationTable<Type>::interpolationTable
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::interpolationTable<Type>::interpolationTable()
+:
+    List<Tuple2<scalar, Type> >(),
+    boundAction_(interpolationTable::WARN),
+    fileName_("undefined_fileName")
+{}
+
+
+template<class Type>
+Foam::interpolationTable<Type>::interpolationTable(const fileName& fn)
+:
+    List<Tuple2<scalar, Type> >(),
+    boundAction_(interpolationTable::WARN),
+    fileName_(fn)
+{
+    readTable();
+}
+
+
+template<class Type>
+Foam::interpolationTable<Type>::interpolationTable(const dictionary& dict)
+:
+    List<Tuple2<scalar, Type> >(),
+    boundAction_(wordToBoundAction(dict.lookup("boundAction"))),
+    fileName_(dict.lookup("fileName"))
+{
+    readTable();
+}
+
+
 template<class Type>
 Foam::interpolationTable<Type>::interpolationTable
 (
@@ -85,18 +92,11 @@ Foam::interpolationTable<Type>::interpolationTable
 )
 :
     List<Tuple2<scalar, Type> >(interpTable),
-    dict_(interpTable.dict_),
     boundAction_(interpTable.boundAction_),
     fileName_(interpTable.fileName_)
 {}
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class Type>
-Foam::interpolationTable<Type>::~interpolationTable()
-{}
-
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -174,7 +174,7 @@ Foam::interpolationTable<Type>::wordToBoundAction
 template<class Type>
 void Foam::interpolationTable<Type>::check() const
 {
-    label n = size();
+    label n = this->size();
     scalar prevValue = List<Tuple2<scalar, Type> >::operator[](0).first();
 
     for (label i=1; i<n; ++i)
@@ -227,7 +227,7 @@ const Foam::Tuple2<Foam::scalar, Type>&
 Foam::interpolationTable<Type>::operator[](const label i) const
 {
     label ii = i;
-    label n  = size();
+    label n  = this->size();
 
     if (n <= 1)
     {
@@ -321,7 +321,7 @@ Foam::interpolationTable<Type>::operator[](const label i) const
 template<class Type>
 Type Foam::interpolationTable<Type>::operator()(const scalar value) const
 {
-    label n = size();
+    label n = this->size();
 
     if (n <= 1)
     {
diff --git a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
index 207e19f91c..77b944cda0 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
+++ b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
@@ -84,9 +84,6 @@ private:
 
     // Private data
 
-        //- Parent dictionary
-        const dictionary& dict_;
-
         //- Enumeration for handling out-of-bound values
         boundActions boundAction_;
 
@@ -94,6 +91,12 @@ private:
         fileName fileName_;
 
 
+    // Private Member Functions
+
+        //- Read the table of data from file
+        void readTable();
+
+
 public:
 
     // Constructors
@@ -101,61 +104,45 @@ public:
         //- Construct null
         interpolationTable();
 
-        //- Construct from objectRegistry and dictionary
-        interpolationTable(const objectRegistry& obr, const dictionary& dict);
+        //- Construct given the name of the file containing the table of data
+        interpolationTable(const fileName& fn);
+
+        //- Construct by reading the fileName and boundAction from dictionary
+        //  and read the table from that file.
+        //  This is a specialised constructor used by patchFields
+        interpolationTable(const dictionary& dict);
 
         //- Construct copy
         interpolationTable(const interpolationTable& interpTable);
 
 
-    //- Destructor
-    ~interpolationTable();
-
-
     // Member Functions
 
-        // Access
+        //- Return the out-of-bounds treatment as a word
+        word boundActionToWord(const boundActions& bound) const;
 
-            //- Return the size
-            label size() const
-            {
-                return List<Tuple2<scalar, Type> >::size();
-            }
+        //- Return the out-of-bounds treatment as an enumeration
+        boundActions wordToBoundAction(const word& bound) const;
 
-            //- Return the out-of-bounds treatment as a word
-            word boundActionToWord(const boundActions& bound) const;
+        //- Check that list is monotonically increasing
+        //  Exit with a FatalError if there is a problem
+        void check() const;
 
-            //- Return the out-of-bounds treatment as an enumeration
-            boundActions wordToBoundAction(const word& bound) const;
+        //- Set the out-of-bounds treatment from enum, return previous
+        //  setting
+        boundActions boundAction(const boundActions& bound);
+
+        //- Write
+        void write(Ostream& os) const;
 
 
-        // Check
+    // Member Operators
 
-            //- Check that list is monotonically increasing
-            //  Exit with a FatalError if there is a problem
-            void check() const;
+        //- Return an element of constant Tuple2<scalar, Type>
+        const Tuple2<scalar, Type>& operator[](const label) const;
 
-
-        // Edit
-
-            //- Set the out-of-bounds treatment from enum, return previous
-            //  setting
-            boundActions boundAction(const boundActions& bound);
-
-
-        // Member Operators
-
-            //- Return an element of constant Tuple2<scalar, Type>
-            const Tuple2<scalar, Type>& operator[](const label) const;
-
-            //- Return an interpolated value
-            Type operator()(const scalar) const;
-
-
-        // I-O
-
-            //- Write
-            void write(Ostream& os) const;
+        //- Return an interpolated value
+        Type operator()(const scalar) const;
 };
 
 
@@ -169,6 +156,8 @@ public:
 #   include "interpolationTable.C"
 #endif
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingFlowRateInletVelocity/timeVaryingFlowRateInletVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingFlowRateInletVelocity/timeVaryingFlowRateInletVelocityFvPatchVectorField.C
index f492d86c77..ba27bdd6fa 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingFlowRateInletVelocity/timeVaryingFlowRateInletVelocityFvPatchVectorField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingFlowRateInletVelocity/timeVaryingFlowRateInletVelocityFvPatchVectorField.C
@@ -30,12 +30,10 @@ License
 #include "fvPatchFieldMapper.H"
 #include "surfaceFields.H"
 #include "Time.H"
-#include "IFstream.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 timeVaryingFlowRateInletVelocityFvPatchVectorField
 (
     const fvPatch& p,
@@ -47,8 +45,7 @@ timeVaryingFlowRateInletVelocityFvPatchVectorField
 {}
 
 
-Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 timeVaryingFlowRateInletVelocityFvPatchVectorField
 (
     const timeVaryingFlowRateInletVelocityFvPatchVectorField& ptf,
@@ -62,8 +59,7 @@ timeVaryingFlowRateInletVelocityFvPatchVectorField
 {}
 
 
-Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 timeVaryingFlowRateInletVelocityFvPatchVectorField
 (
     const fvPatch& p,
@@ -72,12 +68,11 @@ timeVaryingFlowRateInletVelocityFvPatchVectorField
 )
 :
     flowRateInletVelocityFvPatchVectorField(p, iF, dict),
-    timeSeries_(this->db(), dict)
+    timeSeries_(dict)
 {}
 
 
-Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 timeVaryingFlowRateInletVelocityFvPatchVectorField
 (
     const timeVaryingFlowRateInletVelocityFvPatchVectorField& ptf
@@ -88,8 +83,7 @@ timeVaryingFlowRateInletVelocityFvPatchVectorField
 {}
 
 
-Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 timeVaryingFlowRateInletVelocityFvPatchVectorField
 (
     const timeVaryingFlowRateInletVelocityFvPatchVectorField& ptf,
@@ -103,8 +97,7 @@ timeVaryingFlowRateInletVelocityFvPatchVectorField
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+void Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 updateCoeffs()
 {
     if (updated())
@@ -117,8 +110,7 @@ updateCoeffs()
 }
 
 
-void Foam::
-timeVaryingFlowRateInletVelocityFvPatchVectorField::
+void Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
 write(Ostream& os) const
 {
     flowRateInletVelocityFvPatchVectorField::write(os);
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFvPatchField.C b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFvPatchField.C
index dc09d678b2..28b13832a4 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFvPatchField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFvPatchField.C
@@ -26,7 +26,6 @@ License
 
 #include "timeVaryingUniformFixedValueFvPatchField.H"
 #include "Time.H"
-#include "IFstream.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -53,7 +52,7 @@ timeVaryingUniformFixedValueFvPatchField
 )
 :
     fixedValueFvPatchField<Type>(p, iF),
-    timeSeries_(this->db(), dict)
+    timeSeries_(dict)
 {
    if (dict.found("value"))
    {
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C
index 711fccdbc6..897514ced5 100644
--- a/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C
+++ b/src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C
@@ -29,7 +29,6 @@ License
 #include "fvPatchFieldMapper.H"
 #include "volFields.H"
 #include "surfaceFields.H"
-#include "IFstream.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -66,7 +65,7 @@ timeVaryingUniformTotalPressureFvPatchScalarField
     psiName_(dict.lookup("psi")),
     gamma_(readScalar(dict.lookup("gamma"))),
     p0_(readScalar(dict.lookup("p0"))),
-    totalPressureTimeSeries_(this->db(), dict)
+    totalPressureTimeSeries_(dict)
 {
     if (dict.found("value"))
     {
@@ -215,7 +214,8 @@ void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::updateCoeffs()
 }
 
 
-void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::write(Ostream& os) const
+void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::
+write(Ostream& os) const
 {
     fvPatchScalarField::write(os);
     os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;

From 2ccd8322f0a644568dea9737ed49680117c31e21 Mon Sep 17 00:00:00 2001
From: henry <Henry Weller h.weller@opencfd.co.uk>
Date: Tue, 8 Jul 2008 18:54:28 +0100
Subject: [PATCH 08/12] Added scripts and support for packing ThirdParty

---
 bin/foamPackSource            |  8 ++--
 bin/foamPackThirdPartyBin     | 77 +++++++++++++++++++++++++++++++++++
 bin/foamPackThirdPartyGeneral | 70 +++++++++++++++++++++++++++++++
 3 files changed, 152 insertions(+), 3 deletions(-)
 create mode 100755 bin/foamPackThirdPartyBin
 create mode 100755 bin/foamPackThirdPartyGeneral

diff --git a/bin/foamPackSource b/bin/foamPackSource
index 30e52c72da..59772a9e50 100755
--- a/bin/foamPackSource
+++ b/bin/foamPackSource
@@ -73,13 +73,15 @@ find -H $packDir               \
  -a ! -name "core"             \
  -a ! -name "core.[1-9]*"      \
  -a ! -name "log[0-9]*"        \
+ -a ! -name "libccmio*"        \
  -a ! -name "\.ebrowse"        \
 | sed                          \
  -e "\@$packDir/.git/@d"       \
  -e "\@$packDir/lib/@d"        \
- -e '\@applications/bin/@d'       \
- -e '\@/t/@d'                     \
- -e '\@Make[.A-Za-z]*/[^/]*/@d'   \
+ -e "\@libccmio.*/@d"          \
+ -e '\@applications/bin/@d'    \
+ -e '\@/t/@d'                  \
+ -e '\@Make[.A-Za-z]*/[^/]*/@d'\
  > $tmpFile
 
 tar czpf $packFile --files-from $tmpFile
diff --git a/bin/foamPackThirdPartyBin b/bin/foamPackThirdPartyBin
new file mode 100755
index 0000000000..26c165a36a
--- /dev/null
+++ b/bin/foamPackThirdPartyBin
@@ -0,0 +1,77 @@
+#!/bin/sh
+#------------------------------------------------------------------------------
+# =========                 |
+# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+#  \\    /   O peration     |
+#   \\  /    A nd           | Copyright (C) 1991-2008 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
+#
+# Script
+#     foamPackThirdPartyBin <archOptions> [outputDir]
+#
+# Description
+#     Packs and compresses binary version of OpenFOAM ThirdParty for release
+#
+#------------------------------------------------------------------------------
+
+if [ $# = 0 ]
+then
+   echo "Error: archOptionsitecture type expected, exiting"
+   echo
+   echo "Usage : ${0##*/} <archOptions> [outputDir]"
+   echo
+   exit 1
+fi
+archOptions=$1
+arch=${archOptions%%G*}
+
+timeStamp=$(date +%Y-%m-%d)
+packDir=ThirdParty
+packFile=${packDir}.${archOptions}_${timeStamp}.gtgz
+
+# add optional output directory
+if [ -d "$2" ]
+then
+   packFile="$2/$packFile"
+fi
+
+if [ -f $packFile ]
+then
+   echo "Error: $packFile already exists"
+   exit 1
+fi
+
+# get list of directories
+dirList=`find $packDir -type d -name $arch -o -type d -name $archOptions`
+echo
+echo "Packing $archOptions port of $packDir into $packFile"
+echo
+
+tar czpf $packFile $dirList
+
+if [ $? = 0 ]
+then
+   echo "Finished packing and compressing file $packFile"
+else
+   echo "Error: failure packing $packFile"
+   rm -f $packFile 2>/dev/null
+fi
+
+#------------------------------------------------------------------------------
diff --git a/bin/foamPackThirdPartyGeneral b/bin/foamPackThirdPartyGeneral
new file mode 100755
index 0000000000..b874e4a0bd
--- /dev/null
+++ b/bin/foamPackThirdPartyGeneral
@@ -0,0 +1,70 @@
+#!/bin/sh
+#------------------------------------------------------------------------------
+# =========                 |
+# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+#  \\    /   O peration     |
+#   \\  /    A nd           | Copyright (C) 1991-2008 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
+#
+# Script
+#     foamPackThirdPartyGeneral [outputDir]
+#
+# Description
+#     Packs and compresses the OpenFOAM ThirdParty directory for release
+#
+#------------------------------------------------------------------------------
+
+timeStamp=$(date +%Y-%m-%d)
+packDir=ThirdParty
+packFile=${packDir}.General_${timeStamp}.gtgz
+
+if [ ! -d $packDir ]
+then
+   echo "Error: directory $packDir does not exist"
+   exit 1
+fi
+
+# add optional output directory
+if [ -d "$1" ]
+then
+   packFile="$1/$packFile"
+fi
+
+if [ -f $packFile ]
+then
+   echo "Error: $packFile already exists"
+   exit 1
+fi
+
+# Create time stamp file
+# ~~~~~~~~~~~~~~~~~~~~~~
+
+echo $timeStamp 2>/dev/null > $packDir/.timeStamp
+
+# Pack and compress the packFile
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+echo
+echo "Packing $packDir into $packFile"
+echo
+
+foamPackSource $packDir $packFile
+
+#------------------------------------------------------------------------------

From 27a474bed7960a4e1f4985bdc65ea9dd0b0a9362 Mon Sep 17 00:00:00 2001
From: henry <Henry Weller h.weller@opencfd.co.uk>
Date: Tue, 8 Jul 2008 19:13:07 +0100
Subject: [PATCH 09/12] Use rm -rf to avoid warnings for files that have
 already been removed.

---
 .../compressibleLesInterFoam/depthCharge3D/Allclean   |  2 +-
 tutorials/gnemdFoam/Allclean                          | 11 ++++-------
 tutorials/mdEquilibrationFoam/Allclean                |  8 +++-----
 tutorials/rhoCentralFoam/Allclean                     |  2 +-
 4 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/tutorials/compressibleLesInterFoam/depthCharge3D/Allclean b/tutorials/compressibleLesInterFoam/depthCharge3D/Allclean
index 7a7b7f16fe..c422ce058e 100755
--- a/tutorials/compressibleLesInterFoam/depthCharge3D/Allclean
+++ b/tutorials/compressibleLesInterFoam/depthCharge3D/Allclean
@@ -2,4 +2,4 @@
 
 foamCleanTutorials cases
 rm -rf processor*
-rm 0/pd.gz 0/alpha1.gz
+rm -rf 0/pd.gz 0/alpha1.gz
diff --git a/tutorials/gnemdFoam/Allclean b/tutorials/gnemdFoam/Allclean
index 827eacb6ae..11f901ce8e 100755
--- a/tutorials/gnemdFoam/Allclean
+++ b/tutorials/gnemdFoam/Allclean
@@ -4,16 +4,13 @@
 . $WM_PROJECT_DIR/bin/tools/CleanFunctions
 
 cd constrictedChannel
-    rm -rf 0 > /dev/null 2>&1
-    rm Ar-Ar Ar-Ne Ne-Ne > /dev/null 2>&1
-    rm constant/idList
-
+    rm -rf 0
+    rm -rf Ar-Ar Ar-Ne Ne-Ne
+    rm -rf constant/idList
     cleanCase
 cd ..
 
 cd nanoNozzle
-    rm -rf processor[0-9] > /dev/null 2>&1
-
+    rm -rf processor[0-9]
     cleanCase
 cd ..
-
diff --git a/tutorials/mdEquilibrationFoam/Allclean b/tutorials/mdEquilibrationFoam/Allclean
index 7880b1387e..00dd874d76 100755
--- a/tutorials/mdEquilibrationFoam/Allclean
+++ b/tutorials/mdEquilibrationFoam/Allclean
@@ -4,10 +4,8 @@
 . $WM_PROJECT_DIR/bin/tools/CleanFunctions
 
 cd periodicCube
-    rm -rf 0 > /dev/null 2>&1
-    rm Ar-Ar > /dev/null 2>&1
-    rm constant/idList
-
+    rm -rf 0
+    rm -rf Ar-Ar
+    rm -rf constant/idList
     cleanCase
 cd ..
-
diff --git a/tutorials/rhoCentralFoam/Allclean b/tutorials/rhoCentralFoam/Allclean
index cbb826cb1d..c783ce6388 100755
--- a/tutorials/rhoCentralFoam/Allclean
+++ b/tutorials/rhoCentralFoam/Allclean
@@ -24,7 +24,7 @@ do
 
     if [ "$case" = "biconic25-55Run35" ]
     then
-        rm $case/constant/polyMesh/boundary
+        rm -rf $case/constant/polyMesh/boundary
         wclean $case/datToFoam
     fi
 done

From 8d44313d2673051c748211bf2a8a7602d16d2e7c Mon Sep 17 00:00:00 2001
From: henry <Henry Weller h.weller@opencfd.co.uk>
Date: Tue, 8 Jul 2008 23:07:42 +0100
Subject: [PATCH 10/12] Filter-out platforms directory from the source. Pack
 the linux-64 link for gcc.

---
 bin/foamPackSource        | 1 +
 bin/foamPackThirdPartyBin | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/bin/foamPackSource b/bin/foamPackSource
index 59772a9e50..519d18929d 100755
--- a/bin/foamPackSource
+++ b/bin/foamPackSource
@@ -82,6 +82,7 @@ find -H $packDir               \
  -e '\@applications/bin/@d'    \
  -e '\@/t/@d'                  \
  -e '\@Make[.A-Za-z]*/[^/]*/@d'\
+ -e '\@/platforms/@d'          \
  > $tmpFile
 
 tar czpf $packFile --files-from $tmpFile
diff --git a/bin/foamPackThirdPartyBin b/bin/foamPackThirdPartyBin
index 26c165a36a..484c0c1e4b 100755
--- a/bin/foamPackThirdPartyBin
+++ b/bin/foamPackThirdPartyBin
@@ -41,6 +41,7 @@ then
 fi
 archOptions=$1
 arch=${archOptions%%G*}
+arch3264=$(echo "$arch" | sed 's@64@-64@')
 
 timeStamp=$(date +%Y-%m-%d)
 packDir=ThirdParty
@@ -59,7 +60,7 @@ then
 fi
 
 # get list of directories
-dirList=`find $packDir -type d -name $arch -o -type d -name $archOptions`
+dirList=`find $packDir -type d -name $arch -o -type d -name $archOptions -o -type l -name $arch3264`
 echo
 echo "Packing $archOptions port of $packDir into $packFile"
 echo

From 2c8fa3b35f18be5ff3bb2a491c89229f968cc5d4 Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Wed, 9 Jul 2008 00:19:33 +0100
Subject: [PATCH 11/12] typo

---
 .../autoHexMeshDriverLayers.C                 | 2961 -----------------
 .../autoHexMeshDriverShrink.C                 | 1151 -------
 .../autoHexMeshDriver/autoHexMeshDriverSnap.C | 1245 -------
 .../autoHexMeshDriverTemplates.C              |   75 -
 .../fvMeshDistribute/fvMeshDistribute.H       |    2 +-
 5 files changed, 1 insertion(+), 5433 deletions(-)
 delete mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
 delete mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C
 delete mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
 delete mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C

diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
deleted file mode 100644
index 3ebf41390c..0000000000
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverLayers.C
+++ /dev/null
@@ -1,2961 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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 "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"
-#include "OFstream.H"
-#include "layerParameters.H"
-
-// * * * * * * * * * * * * * 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);
-
-    // Pick up all candidate cells on boundary
-    labelHashSet boundaryCells(mesh_.nFaces()-mesh_.nInternalFaces());
-
-    {
-        labelList patchIDs(meshRefinement::addedPatches(globalToPatch_));
-
-        const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-        forAll(patchIDs, i)
-        {
-            label patchI = patchIDs[i];
-
-            const polyPatch& patch = patches[patchI];
-
-            if (!patch.coupled())
-            {
-                forAll(patch, i)
-                {
-                    boundaryCells.insert(mesh_.faceOwner()[patch.start()+i]);
-                }
-            }
-        }
-    }
-
-    // Get all sets of faces that can be merged
-    labelListList allFaceSets
-    (
-        faceCombiner.getMergeSets
-        (
-            minCos,
-            concaveCos,
-            boundaryCells
-        )
-    );
-
-    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;
-//}
-
-
-// No extrusion on faces with differing number of layers for points
-void Foam::autoHexMeshDriver::setNumLayers
-(
-    const labelList& patchToNLayers,
-    const labelList& patchIDs,
-    const indirectPrimitivePatch& pp,
-    pointField& patchDisp,
-    labelList& patchNLayers,
-    List<extrudeMode>& extrudeStatus
-) const
-{
-    Info<< nl << "Handling points with inconsistent layer specification ..."
-        << endl;
-
-    // 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;
-}
-
-
-void Foam::autoHexMeshDriver::calculateLayerThickness
-(
-    const indirectPrimitivePatch& pp,
-    const labelList& patchIDs,
-    const scalarField& patchExpansionRatio,
-    const scalarField& patchFinalLayerRatio,
-    const scalarField& patchRelMinThickness,
-    const labelList& cellLevel,
-    const labelList& patchNLayers,
-    const scalar edge0Len,
-
-    scalarField& thickness,
-    scalarField& minThickness,
-    scalarField& expansionRatio
-) const
-{
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    if (min(patchRelMinThickness) < 0 || max(patchRelMinThickness) > 2)
-    {
-        FatalErrorIn("calculateLayerThickness(..)")
-            << "Thickness should be factor of local undistorted cell size."
-            << " Valid values are [0..2]." << nl
-            << " minThickness:" << patchRelMinThickness
-            << exit(FatalError);
-    }
-
-
-    // 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
-        );
-    }
-
-
-    // Rework patch-wise layer parameters into minimum per point
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    expansionRatio.setSize(pp.nPoints());
-    expansionRatio = GREAT;
-    scalarField finalLayerRatio(pp.nPoints(), GREAT);
-    scalarField relMinThickness(pp.nPoints(), GREAT);
-
-    {
-        forAll(patchIDs, i)
-        {
-            label patchI = patchIDs[i];
-
-            const labelList& meshPoints = patches[patchI].meshPoints();
-
-            forAll(meshPoints, patchPointI)
-            {
-                label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
-
-                expansionRatio[ppPointI] = min
-                (
-                    expansionRatio[ppPointI],
-                    patchExpansionRatio[patchI]
-                );
-                finalLayerRatio[ppPointI] = min
-                (
-                    finalLayerRatio[ppPointI],
-                    patchFinalLayerRatio[patchI]
-                );
-                relMinThickness[ppPointI] = min
-                (
-                    relMinThickness[ppPointI],
-                    patchRelMinThickness[patchI]
-                );
-            }
-        }
-
-        syncTools::syncPointList
-        (
-            mesh_,
-            pp.meshPoints(),
-            expansionRatio,
-            minEqOp<scalar>(),
-            GREAT,              // null value
-            false               // no separation
-        );
-        syncTools::syncPointList
-        (
-            mesh_,
-            pp.meshPoints(),
-            finalLayerRatio,
-            minEqOp<scalar>(),
-            GREAT,              // null value
-            false               // no separation
-        );
-        syncTools::syncPointList
-        (
-            mesh_,
-            pp.meshPoints(),
-            relMinThickness,
-            minEqOp<scalar>(),
-            GREAT,              // null value
-            false               // no separation
-        );
-    }
-
-
-
-    // Per mesh point the expansion parameters
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    thickness.setSize(pp.nPoints());
-    minThickness.setSize(pp.nPoints());
-
-    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[pointI] == 1)
-        {
-            thickness[pointI] =
-                finalLayerRatio[pointI]
-              * patchNLayers[pointI]
-              * edgeLen;
-            minThickness[pointI] = relMinThickness[pointI]*edgeLen;
-        }
-        else
-        {
-            scalar invExpansion = 1.0 / expansionRatio[pointI];
-            label nLay = patchNLayers[pointI];
-            thickness[pointI] =
-                finalLayerRatio[pointI]
-              * edgeLen
-              * (1.0 - pow(invExpansion, nLay))
-              / (1.0 - invExpansion);
-            minThickness[pointI] = relMinThickness[pointI]*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 layerParameters& layerParams,
-    const dictionary& motionDict
-)
-{
-    scalar minCos = Foam::cos
-    (
-        layerParams.featureAngle()
-      * mathematicalConstant::pi/180.0
-    );
-
-    scalar concaveCos = Foam::cos
-    (
-        layerParams.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 < " << layerParams.featureAngle()
-        << " degrees"
-        << nl
-        << "      (cos:" << minCos << ')' << nl
-        << "    - as long as the resulting face doesn't become concave"
-        << " by more than "
-        << layerParams.concaveAngle()
-        << " degrees (0=straight, 180=fully concave)" << nl
-        << endl;
-
-    label nChanged = mergePatchFacesUndo(minCos, concaveCos, motionDict);
-
-    nChanged += mergeEdgesUndo(minCos, motionDict);
-}
-
-
-void Foam::autoHexMeshDriver::addLayers
-(
-    const layerParameters& layerParams,
-    const dictionary& motionDict,
-    const label nAllowableErrors,
-    motionSmoother& meshMover
-)
-{
-    const indirectPrimitivePatch& pp = meshMover.patch();
-    const labelList& meshPoints = pp.meshPoints();
-
-    // Precalculate mesh edge labels for patch edges
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    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
-    (
-        layerParams.numLayers(),    // per patch the num layers
-        meshMover.adaptPatchIDs(),  // patches that are being moved
-        pp,                         // indirectpatch for all faces moving
-
-        patchDisp,
-        patchNLayers,
-        extrudeStatus
-    );
-
-    // Disable extrusion on non-manifold points
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    handleNonManifolds
-    (
-        pp,
-        meshEdges,
-
-        patchDisp,
-        patchNLayers,
-        extrudeStatus
-    );
-
-    // Disable extrusion on feature angles
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    handleFeatureAngle
-    (
-        pp,
-        meshEdges,
-        layerParams.featureAngle()*mathematicalConstant::pi/180.0,
-
-        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,
-        layerParams.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 < layerParams.nGrow(); i++)
-    {
-        growNoExtrusion
-        (
-            pp,
-            patchDisp,
-            patchNLayers,
-            extrudeStatus
-        );
-    }
-
-    // Determine (wanted) point-wise layer thickness and expansion ratio
-    scalarField thickness(pp.nPoints());
-    scalarField minThickness(pp.nPoints());
-    scalarField expansionRatio(pp.nPoints());
-    calculateLayerThickness
-    (
-        pp,
-        meshMover.adaptPatchIDs(),
-        layerParams.expansionRatio(),
-        layerParams.finalLayerRatio(),
-        layerParams.minThickness(),
-        cellLevel,
-        patchNLayers,
-        edge0Len,
-
-        thickness,
-        minThickness,
-        expansionRatio
-    );
-
-    // 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,
-        layerParams.nSmoothNormals(),
-        layerParams.nSmoothSurfaceNormals(),
-        layerParams.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
-            //    layerParams.nSmoothDisp(),
-            //    layerParams.nSnap()
-            //);
-
-            // Medial axis based shrinking
-            shrinkMeshMedialDistance
-            (
-                meshMover,
-
-                layerParams.nSmoothThickness(),
-                layerParams.maxThicknessToMedialRatio(),
-                nAllowableErrors,
-                layerParams.nSnap(),
-                layerParams.layerTerminationCos(),
-
-                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,
-            layerParams.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[i] == 1.0)
-                {
-                    firstDisp[i] = patchDisp[i]/nPatchPointLayers[i];
-                }
-                else
-                {
-                    label nLay = nPatchPointLayers[i];
-                    scalar h =
-                        pow(expansionRatio[i], nLay - 1)
-                      * (mag(patchDisp[i])*(1.0 - expansionRatio[i]))
-                      / (1.0 - pow(expansionRatio[i], nLay));
-                    firstDisp[i] = h/mag(patchDisp[i])*patchDisp[i];
-                }
-            }
-        }
-
-        scalarField 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,
-            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(flaggedFaces, 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
deleted file mode 100644
index 0c66073e84..0000000000
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverShrink.C
+++ /dev/null
@@ -1,1151 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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
deleted file mode 100644
index 8e074cd05e..0000000000
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverSnap.C
+++ /dev/null
@@ -1,1245 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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"
-#include "snapParameters.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().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 snapParameters& snapParams,
-    const indirectPrimitivePatch& pp
-) const
-{
-    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 snapParams.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(globalToPatch_.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 snapParameters& snapParams,
-    const label nInitErrors,
-    const List<labelPair>& baffles,
-    motionSmoother& meshMover
-) const
-{
-    labelList checkFaces;
-
-    Info<< "Smoothing patch points ..." << endl;
-    for
-    (
-        label smoothIter = 0;
-        smoothIter < snapParams.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*snapParams.nSnap(); snapIter++)
-        {
-            Info<< nl << "Scaling iteration " << snapIter << endl;
-
-            if (snapIter == snapParams.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_)
-    {
-        const_cast<Time&>(mesh_.time())++;
-        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;
-}
-
-
-// Get (pp-local) indices of points that are both on zone and on patched surface
-Foam::labelList Foam::autoHexMeshDriver::getZoneSurfacePoints
-(
-    const indirectPrimitivePatch& pp,
-    const word& zoneName
-) const
-{
-    label zoneI = mesh_.faceZones().findZoneID(zoneName);
-
-    if (zoneI == -1)
-    {
-        FatalErrorIn
-        (
-            "autoHexMeshDriver::getZoneSurfacePoints"
-            "(const indirectPrimitivePatch&, const word&)"
-        )   << "Cannot find zone " << zoneName
-            << exit(FatalError);
-    }
-
-    const faceZone& fZone = mesh_.faceZones()[zoneI];
-
-
-    // Could use PrimitivePatch & localFaces to extract points but might just
-    // as well do it ourselves.
-
-    boolList pointOnZone(pp.nPoints(), false);
-
-    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();
-                pointOnZone[pointI] = true;
-            }
-        }
-    }
-
-    return findIndices(pointOnZone, true);
-}
-
-
-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
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    {
-        List<pointIndexHit> hitInfo;
-        labelList hitSurface;
-        surfaces().findNearest
-        (
-            unzonedSurfaces,
-            localPoints,
-            sqr(4*snapDist),        // sqr of attract distance
-            hitSurface,
-            hitInfo
-        );
-
-        forAll(hitInfo, pointI)
-        {
-            if (hitInfo[pointI].hit())
-            {
-                patchDisp[pointI] =
-                    hitInfo[pointI].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);
-
-        // Get indices of points both on faceZone and on pp.
-        labelList zonePointIndices
-        (
-            getZoneSurfacePoints
-            (
-                pp,
-                faceZoneNames[zoneSurfI]
-            )
-        );
-
-        pointField zonePoints(zonePointIndices.size());
-        forAll(zonePointIndices, i)
-        {
-            zonePoints[i] = localPoints[zonePointIndices[i]];
-        }
-
-        // Find nearest for points both on faceZone and pp.
-        List<pointIndexHit> hitInfo;
-        labelList hitSurface;
-        surfaces().findNearest
-        (
-            labelList(1, zoneSurfI),
-            zonePoints,
-            sqr(4*snapDist),
-            hitSurface,
-            hitInfo
-        );
-
-        forAll(hitInfo, pointI)
-        {
-            if (hitInfo[pointI].hit())
-            {
-                patchDisp[pointI] =
-                    hitInfo[pointI].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
-(
-    const snapParameters& snapParams,
-    motionSmoother& meshMover
-) const
-{
-    const pointMesh& pMesh = meshMover.pMesh();
-    const indirectPrimitivePatch& pp = meshMover.patch();
-
-    Info<< "Smoothing displacement ..." << endl;
-
-    // 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 < snapParams.nSmoothDispl(); 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_)
-    {
-        const_cast<Time&>(mesh_.time())++;
-        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 snapParameters& snapParams,
-    const label nInitErrors,
-    const List<labelPair>& baffles,
-    motionSmoother& meshMover
-)
-{
-    // Relax displacement until correct mesh
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    labelList checkFaces(identity(mesh_.nFaces()));
-
-    scalar oldErrorReduction = -1;
-
-    Info<< "Moving mesh ..." << endl;
-    for (label iter = 0; iter < 2*snapParams.nSnap(); iter++)
-    {
-        Info<< nl << "Iteration " << iter << endl;
-
-        if (iter == snapParams.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_)
-        {
-            const_cast<Time&>(mesh_.time())++;
-            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();
-        }
-    }
-
-    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
deleted file mode 100644
index 31807f0dee..0000000000
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriverTemplates.C
+++ /dev/null
@@ -1,75 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 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/dynamicMesh/fvMeshDistribute/fvMeshDistribute.H b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.H
index d764c3fa6f..2db82c8eed 100644
--- a/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.H
+++ b/src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.H
@@ -361,7 +361,7 @@ public:
 
     // Member Functions
 
-        //- Helper funntion: count cells per processor in wanted distribution
+        //- Helper function: count cells per processor in wanted distribution
         static labelList countCells(const labelList&);
 
         //- Send cells to neighbours according to distribution

From 15cad22d8c06b17cb620020198635d389ac768ca Mon Sep 17 00:00:00 2001
From: mattijs <m.janssens@opencfd.co.uk>
Date: Wed, 9 Jul 2008 00:21:36 +0100
Subject: [PATCH 12/12] split autoHexMeshDriver; updated header

---
 .../generation/snappyHexMesh/snappyHexMesh.C  |  342 +-
 .../snappyHexMesh/snappyHexMeshDict           |   50 +-
 src/autoMesh/Make/files                       |    8 +-
 .../autoHexMeshDriver/autoHexMeshDriver.C     | 1784 ++--------
 .../autoHexMeshDriver/autoHexMeshDriver.H     |  651 +---
 .../autoHexMeshDriver/autoLayerDriver.C       | 3128 +++++++++++++++++
 .../autoHexMeshDriver/autoLayerDriver.H       |  562 +++
 .../autoHexMeshDriver/autoLayerDriverShrink.C | 1159 ++++++
 .../autoLayerDriverTemplates.C                |   76 +
 .../autoHexMeshDriver/autoRefineDriver.C      |  776 ++++
 .../autoHexMeshDriver/autoRefineDriver.H      |  179 +
 .../autoHexMeshDriver/autoSnapDriver.C        | 1385 ++++++++
 .../autoHexMeshDriver/autoSnapDriver.H        |  236 ++
 .../layerParameters/layerParameters.C         |  118 +-
 .../layerParameters/layerParameters.H         |   19 +-
 .../meshRefinement/meshRefinement.C           |  236 +-
 .../meshRefinement/meshRefinement.H           |   34 +-
 .../refinementSurfaces/refinementSurfaces.H   |    9 +-
 .../searchableSurface/searchableBox.C         |    2 +-
 .../searchableSurface/searchableBox.H         |    2 +-
 .../searchableSurface/searchableSphere.C      |    2 +-
 .../searchableSurface/searchableSphere.H      |    2 +-
 .../searchableSurface/searchableSurface.C     |    2 +-
 .../searchableSurface/searchableSurface.H     |    2 +-
 .../searchableSurface/searchableSurfaces.C    |    2 +-
 .../searchableSurface/searchableSurfaces.H    |    2 +-
 .../searchableSurfacesQueries.C               |    2 +-
 .../searchableSurfacesQueries.H               |    2 +-
 .../searchableSurface/triSurfaceMesh.C        |    2 +-
 .../searchableSurface/triSurfaceMesh.H        |    2 +-
 30 files changed, 8501 insertions(+), 2275 deletions(-)
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverTemplates.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
 create mode 100644 src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H

diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
index e53f8f68d3..15be3f9c1d 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,12 +33,86 @@ Description
 #include "argList.H"
 #include "Time.H"
 #include "fvMesh.H"
-#include "autoHexMeshDriver.H"
+#include "autoRefineDriver.H"
+#include "autoSnapDriver.H"
+#include "autoLayerDriver.H"
+#include "searchableSurfaces.H"
+#include "refinementSurfaces.H"
+#include "shellSurfaces.H"
+#include "decompositionMethod.H"
+#include "fvMeshDistribute.H"
+#include "wallPolyPatch.H"
+#include "refinementParameters.H"
+#include "snapParameters.H"
+#include "layerParameters.H"
+
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// Check writing tolerance before doing any serious work
+scalar getMergeDistance(const polyMesh& mesh, const scalar mergeTol)
+{
+    const boundBox& meshBb = mesh.bounds();
+    scalar mergeDist = mergeTol*mag(meshBb.max() - meshBb.min());
+    scalar writeTol = std::pow
+    (
+        scalar(10.0),
+       -scalar(IOstream::defaultPrecision())
+    );
+
+    Info<< nl
+        << "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("getMergeDistance(const polyMesh&, const scalar)")
+            << "Your current settings specify ASCII writing with "
+            << IOstream::defaultPrecision() << " digits precision." << endl
+            << "Your merging tolerance (" << mergeTol << ") is finer than this."
+            << endl
+            << "Please change your writeFormat to binary"
+            << " or increase the writePrecision" << endl
+            << "or adjust the merge tolerance (-mergeTol)."
+            << exit(FatalError);
+    }
+
+    return mergeDist;
+}
+
+
+// Write mesh and additional information
+void writeMesh
+(
+    const string& msg,
+    const meshRefinement& meshRefiner,
+    const label debug
+)
+{
+    const fvMesh& mesh = meshRefiner.mesh();
+
+    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;
+}
+
+
+
 int main(int argc, char *argv[])
 {
 #   include "setRootCase.H"
@@ -49,6 +123,11 @@ int main(int argc, char *argv[])
     Info<< "Read mesh in = "
         << runTime.cpuTimeIncrement() << " s" << endl;
 
+    // Check patches and faceZones are synchronised
+    mesh.boundaryMesh().checkParallelSync(true);
+    meshRefinement::checkCoupledFaceZones(mesh);
+
+
     // Read decomposePar dictionary
     IOdictionary decomposeDict
     (
@@ -75,51 +154,282 @@ int main(int argc, char *argv[])
        )
     );
 
-    // refinement parameters
-    const dictionary& refineDict = meshDict.subDict("castellatedMeshControls");
-
     // all surface geometry
     const dictionary& geometryDict = meshDict.subDict("geometry");
 
-    // snap-to-surface parameters
-    const dictionary& snapDict = meshDict.subDict("snapControls");
+    // refinement parameters
+    const dictionary& refineDict = meshDict.subDict("castellatedMeshControls");
 
     // mesh motion and mesh quality parameters
     const dictionary& motionDict = meshDict.subDict("meshQualityControls");
 
+    // snap-to-surface parameters
+    const dictionary& snapDict = meshDict.subDict("snapControls");
+
     // layer addition parameters
     const dictionary& layerDict = meshDict.subDict("addLayersControls");
 
 
-    // Main meshing driver. Read surfaces. Determine initial intersections.
-    autoHexMeshDriver meshEngine
+
+    // Debug
+    // ~~~~~
+
+    const label debug(readLabel(meshDict.lookup("debug")));
+    if (debug > 0)
+    {
+        meshRefinement::debug = debug;
+        autoRefineDriver::debug = debug;
+        autoSnapDriver::debug = debug;
+        autoLayerDriver::debug = debug;
+    }        
+
+
+    // Read geometry
+    // ~~~~~~~~~~~~~
+
+    searchableSurfaces allGeometry
+    (
+        IOobject
+        (
+            "abc",                      // dummy name
+            mesh.time().constant(),     // directory
+            "triSurface",               // instance
+            mesh.time(),                // registry
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        ),
+        geometryDict
+    );
+
+
+    // Read refinement surfaces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Info<< "Reading refinement surfaces." << endl;
+    refinementSurfaces surfaces
+    (
+        allGeometry,
+        refineDict.subDict("refinementSurfaces")
+    );
+    Info<< "Read refinement surfaces in = "
+        << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
+    // Read refinement shells
+    // ~~~~~~~~~~~~~~~~~~~~~~
+
+    Info<< "Reading refinement shells." << endl;
+    shellSurfaces shells
+    (
+        allGeometry,
+        refineDict.subDict("refinementRegions")
+    );
+    Info<< "Read refinement shells in = "
+        << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
+    Info<< "Setting refinement level of surface to be consistent"
+        << " with shells." << endl;
+    surfaces.setMinLevelFields(shells);
+    Info<< "Checked shell refinement in = "
+        << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+
+
+
+
+    // Add all the surface regions as patches
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    labelList globalToPatch;
+    {
+        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;
+
+        const labelList& surfaceGeometry = surfaces.surfaces();
+        forAll(surfaceGeometry, surfI)
+        {
+            label geomI = surfaceGeometry[surfI];
+
+            const wordList& regNames = allGeometry.regionNames()[geomI];
+
+            Info<< surfaces.names()[surfI] << ':' << nl << nl;
+
+            forAll(regNames, i)
+            {
+                label patchI = meshRefinement::addPatch
+                (
+                    mesh,
+                    regNames[i],
+                    wallPolyPatch::typeName
+                );
+
+                Info<< patchI << '\t' << regNames[i] << nl;
+
+                globalToPatch[surfaces.globalRegion(surfI, i)] = patchI;
+            }
+
+            Info<< nl;
+        }
+        Info<< "Added patches in = "
+            << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+    }
+
+
+    // Parallel
+    // ~~~~~~~~
+
+    // Decomposition
+    autoPtr<decompositionMethod> decomposerPtr
+    (
+        decompositionMethod::New
+        (
+            decomposeDict,
+            mesh
+        )
+    );
+    decompositionMethod& decomposer = decomposerPtr();
+
+    if (Pstream::parRun() && !decomposer.parallelAware())
+    {
+        FatalErrorIn(args.executable())
+            << "You have selected decomposition method "
+            << decomposer.typeName
+            << " which is not parallel aware." << endl
+            << "Please select one that is (hierarchical, parMetis)"
+            << exit(FatalError);
+    }
+
+    const scalar mergeDist = getMergeDistance
     (
         mesh,
-        meshDict,       // global control parameters
-        geometryDict,
-        refineDict,     // refinement parameters
-        decomposeDict
+        readScalar(meshDict.lookup("mergeTolerance"))
     );
 
+
+    // Mesh distribution engine (uses tolerance to reconstruct meshes)
+    fvMeshDistribute distributor(mesh, mergeDist);
+
+
+    // Refinement engine
+    // ~~~~~~~~~~~~~~~~~
+
+    Info<< nl
+        << "Determining initial surface intersections" << nl
+        << "-----------------------------------------" << nl
+        << endl;
+
+    // Main refinement engine
+    meshRefinement meshRefiner
+    (
+        mesh,
+        mergeDist,          // tolerance used in sorting coordinates
+        surfaces,           // for surface intersection refinement
+        shells              // for volume (inside/outside) refinement
+    );
+    Info<< "Calculated surface intersections in = "
+        << mesh.time().cpuTimeIncrement() << " s" << nl << endl;
+
+    // Some stats
+    meshRefiner.printMeshInfo(debug, "Initial mesh");
+
+    meshRefiner.write
+    (
+        debug&meshRefinement::OBJINTERSECTIONS,
+        mesh.time().path()/mesh.time().timeName()
+    );
+
+
+
+
+    // Now do the real work -refinement -snapping -layers
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
     Switch wantRefine(meshDict.lookup("castellatedMesh"));
     Switch wantSnap(meshDict.lookup("snap"));
     Switch wantLayers(meshDict.lookup("addLayers"));
 
     if (wantRefine)
     {
-        meshEngine.doRefine(refineDict, wantSnap);
+        autoRefineDriver refineDriver
+        (
+            meshRefiner,
+            decomposer,
+            distributor,
+            globalToPatch
+        );
+
+        // Refinement parameters
+        refinementParameters refineParams(refineDict);
+
+        refineDriver.doRefine(refineDict, refineParams, wantSnap);
+
+        writeMesh
+        (
+            "Refined mesh",
+            meshRefiner,
+            debug
+        );
     }
 
     if (wantSnap)
     {
-        meshEngine.doSnap(snapDict, motionDict);
+        autoSnapDriver snapDriver
+        (
+            meshRefiner,
+            globalToPatch
+        );
+
+        // Snap parameters
+        snapParameters snapParams(snapDict);
+
+        snapDriver.doSnap(snapDict, motionDict, snapParams);
+
+        writeMesh
+        (
+            "Snapped mesh",
+            meshRefiner,
+            debug
+        );
     }
 
     if (wantLayers)
     {
-        meshEngine.doLayers(layerDict, motionDict);
+        autoLayerDriver layerDriver
+        (
+            meshRefiner,
+            globalToPatch
+        );
+
+        // Layer addition parameters
+        layerParameters layerParams(layerDict, mesh.boundaryMesh());
+
+        layerDriver.doLayers
+        (
+            layerDict,
+            motionDict,
+            layerParams,
+            decomposer,
+            distributor
+        );
+
+        writeMesh
+        (
+            "Layer mesh",
+            meshRefiner,
+            debug
+        );
     }
 
+
     Info<< "Finished meshing in = "
         << runTime.elapsedCpuTime() << " s." << endl;
 
diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
index 4e71557fdb..e97b1ee9a7 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
@@ -36,26 +36,26 @@ addLayers       false;
 // - to 'snap' the mesh boundary to the surface
 geometry
 {
-//    box1x1x1
-//    {
-//        type searchableBox;
-//        min (1.5 1 -0.5);
-//        max (3.5 2 0.5);
-//    }
-//
-//    sphere.stl
-//    {
-//        type triSurfaceMesh;
-//
-//        // Per region the patchname. If not provided will be <name>_<region>.
-//        regions
-//        {
-//            secondSolid
-//            {
-//                name mySecondPatch;
-//            }
-//        }
-//    }
+    box1x1x1
+    {
+        type searchableBox;
+        min (1.5 1 -0.5);
+        max (3.5 2 0.5);
+    }
+
+    sphere.stl
+    {
+        type triSurfaceMesh;
+
+        // Per region the patchname. If not provided will be <name>_<region>.
+        regions
+        {
+            secondSolid
+            {
+                name mySecondPatch;
+            }
+        }
+    }
 
     sphere2
     {
@@ -159,11 +159,11 @@ castellatedMeshControls
 
     refinementRegions
     {
-        //box1x1x1
-        //{
-        //    mode inside;
-        //    levels ((1.0 4));
-        //}
+        box1x1x1
+        {
+            mode inside;
+            levels ((1.0 4));
+        }
         //sphere.stl
         //{
         //    mode distance;
diff --git a/src/autoMesh/Make/files b/src/autoMesh/Make/files
index 1c763a316c..96141445be 100644
--- a/src/autoMesh/Make/files
+++ b/src/autoMesh/Make/files
@@ -1,10 +1,12 @@
 autoHexMesh             = autoHexMesh
 autoHexMeshDriver       = $(autoHexMesh)/autoHexMeshDriver
 
+$(autoHexMeshDriver)/autoLayerDriver.C
+$(autoHexMeshDriver)/autoLayerDriverShrink.C
+$(autoHexMeshDriver)/autoSnapDriver.C
+$(autoHexMeshDriver)/autoRefineDriver.C
 $(autoHexMeshDriver)/autoHexMeshDriver.C
-$(autoHexMeshDriver)/autoHexMeshDriverLayers.C
-$(autoHexMeshDriver)/autoHexMeshDriverShrink.C
-$(autoHexMeshDriver)/autoHexMeshDriverSnap.C
+
 $(autoHexMeshDriver)/layerParameters/layerParameters.C
 $(autoHexMeshDriver)/refinementParameters/refinementParameters.C
 $(autoHexMeshDriver)/snapParameters/snapParameters.C
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
index 94c217ebcc..48f52d7880 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
@@ -38,6 +38,10 @@ License
 #include "refinementParameters.H"
 #include "snapParameters.H"
 #include "layerParameters.H"
+#include "autoRefineDriver.H"
+#include "autoSnapDriver.H"
+#include "autoLayerDriver.H"
+#include "triSurfaceMesh.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -87,7 +91,10 @@ Foam::scalar Foam::autoHexMeshDriver::getMergeDistance(const scalar mergeTol)
 
 
 //// Specifically orient using a calculated point outside
-//void Foam::autoHexMeshDriver::orientOutside(PtrList<searchableSurface>& shells)
+//void Foam::autoHexMeshDriver::orientOutside
+//(
+//    PtrList<searchableSurface>& shells
+//)
 //{
 //    // Determine outside point.
 //    boundBox overallBb
@@ -124,7 +131,8 @@ Foam::scalar Foam::autoHexMeshDriver::getMergeDistance(const scalar mergeTol)
 //        {
 //            if (isA<triSurfaceMesh>(shells[shellI]))
 //            {
-//                triSurfaceMesh& shell = refCast<triSurfaceMesh>(shells[shellI]);
+//                triSurfaceMesh& shell =
+//                  refCast<triSurfaceMesh>(shells[shellI]);
 //
 //                if (!refinementSurfaces::isSurfaceClosed(shell))
 //                {
@@ -141,584 +149,154 @@ Foam::scalar Foam::autoHexMeshDriver::getMergeDistance(const scalar mergeTol)
 //}
 
 
-// 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"))),
-//    mergeDist_(getMergeDistance(readScalar(dict_.lookup("mergeTolerance"))))
-//{
-//    if (debug_ > 0)
-//    {
-//        meshRefinement::debug = debug_;
-//        autoHexMeshDriver::debug = debug_;
-//    }
-//
-//    refinementParameters refineParams(dict);
-//
-//    Info<< "Overall cell limit                         : "
-//        << refineParams.maxGlobalCells() << endl;
-//    Info<< "Per processor cell limit                   : "
-//        << refineParams.maxLocalCells() << endl;
-//    Info<< "Minimum number of cells to refine          : "
-//        << refineParams.minRefineCells() << endl;
-//    Info<< "Curvature                                  : "
-//        << refineParams.curvature() << nl << endl;
-//    Info<< "Layers between different refinement levels : "
-//        << refineParams.nBufferLayers() << endl;
-//
-////XXXXX
-//    PtrList<dictionary> shellsDict(dict_.lookup("refinementShells"));
-//
-//    PtrList<dictionary> surfacesDict(dict_.lookup("surfaces"));
-//
-//
-//    // Read geometry
-//    // ~~~~~~~~~~~~~
-//
-//    {
-//        Info<< "Reading all geometry." << endl;
-//
-//        // Construct dictionary with all shells and all refinement surfaces
-//        dictionary geometryDict;
-//
-//        forAll(shellsDict, shellI)
-//        {
-//            dictionary shellDict = shellsDict[shellI];
-//            const word name(shellDict.lookup("name"));
-//            shellDict.remove("name");
-//            shellDict.remove("level");
-//            shellDict.remove("refineInside");
-//            geometryDict.add(name, shellDict);
-//        }
-//
-//        forAll(surfacesDict, surfI)
-//        {
-//            dictionary surfDict = surfacesDict[shellI];
-//            const word name(string::validate<word>(surfDict.lookup("file")));
-//            surfDict.remove("file");
-//            if (!surfDict.found("name"))
-//            {
-//                surfDict.add("name", name);
-//            }
-//            geometryDict.add(name, iter());
-//        }
-//
-//        allGeometryPtr_.reset
-//        (
-//            new searchableSurfaces
-//            (
-//                IOobject
-//                (
-//                    "abc",                      // dummy name
-//                    mesh_.time().constant(),    // directory
-//                    "triSurface",               // instance
-//                    mesh_.time(),               // registry
-//                    IOobject::MUST_READ,
-//                    IOobject::NO_WRITE
-//                ),
-//                geometryDict
-//            )
-//        );
-//
-//        Info<< "Read geometry in = "
-//            << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
-//    }
-//
-//
-//    // Read refinement surfaces
-//    // ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-//    {
-//        Info<< "Reading surfaces and constructing search trees." << endl;
-//
-//        surfacesPtr_.reset
-//        (
-//            new refinementSurfaces
-//            (
-//                allGeometryPtr_(),
-//                surfacesDict
-//            )
-//        );
-//        Info<< "Read surfaces in = "
-//            << mesh_.time().cpuTimeIncrement() << " s" << endl;
-//    }
-//
-//    // 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 globalRegionI = surfaces().globalRegion(surfI, i);
-//
-//                    // Use optionally specified patch type and name
-//                    word patchType = surfaces().patchType()[globalRegionI];
-//                    if (patchType == "")
-//                    {
-//                        patchType = wallPolyPatch::typeName;
-//                    }
-//
-//                    word patchName = surfaces().patchName()[globalRegionI];
-//                    if (patchName == "")
-//                    {
-//                        patchName =
-//                            surfaces().names()[surfI]
-//                          + '_'
-//                          + regions[i].name();
-//                    }
-//
-//                    label patchI = meshRefinement::addPatch
-//                    (
-//                        mesh,
-//                        patchName,
-//                        patchType
-//                    );
-//
-//                    Info<< patchI << '\t' << regions[i].name() << nl;
-//
-//                    globalToPatch_[globalRegionI] = 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()
-//        );
-//    }
-//}
-
-
-// Construct from separate dictionaries.
+// Construct from components
 Foam::autoHexMeshDriver::autoHexMeshDriver
 (
     fvMesh& mesh,
-    const dictionary& controlDict,
-    const dictionary& geometryDict,
-    const dictionary& refineDict,
+    const dictionary& dict,
     const dictionary& decomposeDict
 )
 :
     mesh_(mesh),
-    dict_(controlDict),
-    debug_(readLabel(controlDict.lookup("debug"))),
-    mergeDist_
-    (
-        getMergeDistance(readScalar(controlDict.lookup("mergeTolerance")))
-    )
+    dict_(dict),
+    debug_(readLabel(dict_.lookup("debug"))),
+    mergeDist_(getMergeDistance(readScalar(dict_.lookup("mergeTolerance"))))
 {
     if (debug_ > 0)
     {
         meshRefinement::debug = debug_;
         autoHexMeshDriver::debug = debug_;
+        autoRefineDriver::debug = debug;
+        autoSnapDriver::debug = debug;
+        autoLayerDriver::debug = debug;
     }
 
+    refinementParameters refineParams(dict, 1);
+
+    Info<< "Overall cell limit                         : "
+        << refineParams.maxGlobalCells() << endl;
+    Info<< "Per processor cell limit                   : "
+        << refineParams.maxLocalCells() << endl;
+    Info<< "Minimum number of cells to refine          : "
+        << refineParams.minRefineCells() << endl;
+    Info<< "Curvature                                  : "
+        << refineParams.curvature() << nl << endl;
+    Info<< "Layers between different refinement levels : "
+        << refineParams.nBufferLayers() << endl;
+
+    PtrList<dictionary> shellDicts(dict_.lookup("refinementShells"));
+
+    PtrList<dictionary> surfaceDicts(dict_.lookup("surfaces"));
+
+
     // Read geometry
     // ~~~~~~~~~~~~~
 
-    Info<< "Reading all geometry." << endl;
-    allGeometryPtr_.reset
-    (
-        new searchableSurfaces
+    {
+        Info<< "Reading all geometry." << endl;
+
+        // Construct dictionary with all shells and all refinement surfaces
+        dictionary geometryDict;
+
+        forAll(shellDicts, shellI)
+        {
+            dictionary shellDict = shellDicts[shellI];
+            const word name(shellDict.lookup("name"));
+            shellDict.remove("name");
+            shellDict.remove("level");
+            shellDict.remove("refineInside");
+            geometryDict.add(name, shellDict);
+        }
+
+        forAll(surfaceDicts, surfI)
+        {
+            dictionary surfDict = surfaceDicts[surfI];
+            const word name(string::validate<word>(surfDict.lookup("file")));
+            surfDict.remove("file");
+            surfDict.remove("regions");
+            if (!surfDict.found("name"))
+            {
+                surfDict.add("name", name);
+            }
+            surfDict.add("type", triSurfaceMesh::typeName);
+            geometryDict.add(name, surfDict);
+        }
+
+        allGeometryPtr_.reset
         (
-            IOobject
+            new searchableSurfaces
             (
-                "abc",                      // dummy name
-                mesh_.time().constant(),    // directory
-                "triSurface",               // instance
-                mesh_.time(),               // registry
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            ),
-            geometryDict
-        )
-    );
-    Info<< "Read geometry in = "
-        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+                IOobject
+                (
+                    "abc",                      // dummy name
+                    mesh_.time().constant(),    // directory
+                    "triSurface",               // instance
+                    mesh_.time(),               // registry
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE
+                ),
+                geometryDict
+            )
+        );
+
+        Info<< "Read geometry in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
 
 
     // Read refinement surfaces
     // ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    Info<< "Reading refinement surfaces." << endl;
-    surfacesPtr_.reset
-    (
-        new refinementSurfaces
-        (
-            allGeometryPtr_(),
-            refineDict.subDict("refinementSurfaces")
-        )
-    );
-    Info<< "Read refinement surfaces in = "
-        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+    {
+        Info<< "Reading surfaces and constructing search trees." << endl;
 
+        surfacesPtr_.reset
+        (
+            new refinementSurfaces
+            (
+                allGeometryPtr_(),
+                surfaceDicts
+            )
+        );
+        Info<< "Read surfaces in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
 
     // Read refinement shells
     // ~~~~~~~~~~~~~~~~~~~~~~
 
-    Info<< "Reading refinement shells." << endl;
-    shellsPtr_.reset
-    (
-        new shellSurfaces
+    {
+        Info<< "Reading refinement shells." << endl;
+        shellsPtr_.reset
         (
-            allGeometryPtr_(),
-            refineDict.subDict("refinementRegions")
-        )
-    );
-    Info<< "Read refinement shells in = "
-        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+            new shellSurfaces
+            (
+                allGeometryPtr_(),
+                shellDicts
+            )
+        );
+        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;
 
-    Info<< "Setting refinement level of surface to be consistent"
-        << " with shells." << endl;
-    surfacesPtr_().setMinLevelFields(shells());
-    Info<< "Checked shell refinement in = "
-        << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
-
+        Info<< "Setting refinement level of surface to be consistent"
+            << " with shells." << endl;
+        surfacesPtr_().setMinLevelFields(shells());
+        Info<< "Checked shell refinement in = "
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
+    }
 
 
     // Check faceZones are synchronised
-    checkCoupledFaceZones();
+    meshRefinement::checkCoupledFaceZones(mesh_);
 
 
     // Add all the surface regions as patches
@@ -757,7 +335,6 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
                     label patchI = meshRefinement::addPatch
                     (
                         mesh,
-                        //s.searchableSurface::name() + '_' + regions[i].name(),
                         regNames[i],
                         wallPolyPatch::typeName
                     );
@@ -774,6 +351,46 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
             << mesh_.time().cpuTimeIncrement() << " s" << nl << 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
     // ~~~~~~~~
 
@@ -789,7 +406,8 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
 
         if (Pstream::parRun() && !decomposer.parallelAware())
         {
-            FatalErrorIn("autoHexMeshDriver::autoHexMeshDriver(const IOobject&, fvMesh&)")
+            FatalErrorIn("autoHexMeshDriver::autoHexMeshDriver"
+                "(const IOobject&, fvMesh&)")
                 << "You have selected decomposition method "
                 << decomposer.typeName
                 << " which is not parallel aware." << endl
@@ -818,12 +436,12 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
             (
                 mesh,
                 mergeDist_,         // tolerance used in sorting coordinates
-                surfaces(),         // for surface intersection refinement
-                shells()            // for volume (inside/outside) refinement
+                surfaces(),
+                shells()
             )
         );
         Info<< "Calculated surface intersections in = "
-            << mesh_.time().cpuTimeIncrement() << " s" << nl << endl;
+            << mesh_.time().cpuTimeIncrement() << " s" << endl;
 
         // Some stats
         meshRefinerPtr_().printMeshInfo(debug_, "Initial mesh");
@@ -839,751 +457,6 @@ Foam::autoHexMeshDriver::autoHexMeshDriver
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// Read explicit feature edges
-Foam::label Foam::autoHexMeshDriver::readFeatureEdges
-(
-    const PtrList<dictionary>& featDicts
-)
-{
-    Info<< "Reading external feature lines." << endl;
-
-    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" << nl << endl;
-
-    return featureMeshes_.size();
-}
-
-
-Foam::label Foam::autoHexMeshDriver::featureEdgeRefine
-(
-    const refinementParameters& refineParams,
-    const PtrList<dictionary>& featDicts,
-    const label maxIter,
-    const label minRefine
-)
-{
-    // Read explicit feature edges
-    readFeatureEdges(featDicts);
-
-    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
-                (
-                    refineParams.keepPoints()[0],    // For now only use one.
-                    refineParams.curvature(),
-
-                    featureMeshes_,
-                    featureLevels_,
-
-                    true,               // featureRefinement
-                    false,              // internalRefinement
-                    false,              // surfaceRefinement
-                    false,              // curvatureRefinement
-                    refineParams.maxGlobalCells(),
-                    refineParams.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 refinementParameters& refineParams,
-    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
-            (
-                refineParams.keepPoints()[0],
-                refineParams.curvature(),
-
-                featureMeshes_,
-                featureLevels_,
-
-                false,              // featureRefinement
-                false,              // internalRefinement
-                true,               // surfaceRefinement
-                true,               // curvatureRefinement
-                refineParams.maxGlobalCells(),
-                refineParams.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 <= refineParams.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 refinementParameters& refineParams,
-    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_,
-        refineParams.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 refinementParameters& refineParams,
-    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 = shells().maxLevel();
-
-    label iter;
-    for (iter = 0; iter < maxIter; iter++)
-    {
-        Info<< nl
-            << "Shell refinement iteration " << iter << nl
-            << "----------------------------" << nl
-            << endl;
-
-        labelList candidateCells
-        (
-            meshRefiner.refineCandidates
-            (
-                refineParams.keepPoints()[0],
-                refineParams.curvature(),
-
-                featureMeshes_,
-                featureLevels_,
-
-                false,              // featureRefinement
-                true,               // internalRefinement
-                false,              // surfaceRefinement
-                false,              // curvatureRefinement
-                refineParams.maxGlobalCells(),
-                refineParams.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 (refineParams.nBufferLayers() <= 2)
-        {
-            cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement
-            (
-                refineParams.nBufferLayers(),
-                candidateCells,                 // cells to refine
-                bFaces,                         // faces for nBufferLayers
-                1,                              // point difference
-                meshRefiner.intersectedPoints() // points to check
-            );
-        }
-        else
-        {
-            cellsToRefine = meshRefiner.meshCutter().consistentSlowRefinement2
-            (
-                refineParams.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 <= refineParams.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 refinementParameters& refineParams,
-    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_,
-        refineParams.keepPoints()[0]
-    );
-}
-
-
-void Foam::autoHexMeshDriver::zonify
-(
-    const refinementParameters& refineParams
-)
-{
-    // 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(refineParams.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 refinementParameters& refineParams,
-    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_,
-        refineParams.keepPoints()[0]
-    );
-
-    if (debug_)
-    {
-        const_cast<Time&>(mesh_.time())++;
-    }
-
-    // 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
-(
-    const refinementParameters& refineParams
-)
-{
-    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),
-        meshRefinement::addedPatches(globalToPatch_)
-    );
-
-    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_();
@@ -1605,272 +478,6 @@ void Foam::autoHexMeshDriver::writeMesh(const string& msg) const
 }
 
 
-
-
-void Foam::autoHexMeshDriver::doRefine
-(
-    const dictionary& refineDict,
-    const bool prepareForSnapping
-)
-{
-    Info<< nl
-        << "Refinement phase" << nl
-        << "----------------" << nl
-        << endl;
-
-    const_cast<Time&>(mesh_.time())++;
-
-    // Get all the refinement specific params
-    refinementParameters refineParams(refineDict);
-
-    // Check that all the keep points are inside the mesh.
-    refineParams.findCells(mesh_);
-
-    PtrList<dictionary> featDicts(refineDict.lookup("features"));
-
-    // Refine around feature edges
-    featureEdgeRefine
-    (
-        refineParams,
-        featDicts,
-        100,    // maxIter
-        0       // min cells to refine
-    );
-
-    // Refine based on surface
-    surfaceOnlyRefine
-    (
-        refineParams,
-        100     // maxIter
-    );
-
-    // Remove cells (a certain distance) beyond surface intersections
-    removeInsideCells
-    (
-        refineParams,
-        1       // nBufferLayers
-    );
-
-    // Internal mesh refinement
-    shellRefine
-    (
-        refineParams,
-        100    // maxIter
-    );
-
-    // Introduce baffles at surface intersections
-    baffleAndSplitMesh(refineParams, prepareForSnapping);
-
-    // Mesh is at its finest. Do optional zoning.
-    zonify(refineParams);
-
-    // Pull baffles apart
-    splitAndMergeBaffles(refineParams, prepareForSnapping);
-
-    // Do something about cells with refined faces on the boundary
-    if (prepareForSnapping)
-    {
-        mergePatchFaces(refineParams);
-    }
-
-    // Do final balancing. Keep zoned faces on one processor.
-    balance(true, false);
-
-    // Write mesh
-    writeMesh("Refined mesh");
-}
-
-
-void Foam::autoHexMeshDriver::doSnap
-(
-    const dictionary& snapDict,
-    const dictionary& motionDict
-)
-{
-    Info<< nl
-        << "Morphing phase" << nl
-        << "--------------" << nl
-        << endl;
-
-    const_cast<Time&>(mesh_.time())++;
-
-    // Get all the snapping specific params
-    snapParameters snapParams(snapDict);
-
-    // 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(snapParams, pp));
-
-
-        // Construct iterative mesh mover.
-        Info<< "Constructing mesh displacer ..." << endl;
-        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(snapParams, nInitErrors, baffles, meshMover);
-
-        // Calculate displacement at every patch point. Insert into
-        // meshMover.
-        calcNearestSurface(snapDist, meshMover);
-
-        // Get smoothly varying internal displacement field.
-        smoothDisplacement(snapParams, meshMover);
-
-        // Apply internal displacement to mesh.
-        scaleMesh(snapParams, nInitErrors, baffles, meshMover);
-    }
-
-    // Merge any introduced baffles.
-    mergeZoneBaffles(baffles);
-
-    // Write mesh.
-    writeMesh("Snapped mesh");
-}
-
-
-void Foam::autoHexMeshDriver::doLayers
-(
-    const dictionary& shrinkDict,
-    const dictionary& motionDict
-)
-{
-    Info<< nl
-        << "Shrinking and layer addition phase" << nl
-        << "----------------------------------" << nl
-        << endl;
-
-    const_cast<Time&>(mesh_.time())++;
-
-    // Get all the layer specific params
-    layerParameters layerParams(shrinkDict, mesh_.boundaryMesh());
-
-    Info<< "Using mesh parameters " << motionDict << nl << endl;
-
-    // Merge coplanar boundary faces
-    mergePatchFacesUndo(layerParams, motionDict);
-
-    // Per patch the number of layers (0 if no layer)
-    const labelList& numLayers = layerParams.numLayers();
-
-    // Patches that need to get a layer
-    DynamicList<label> patchIDs(numLayers.size());
-    label nFacesWithLayers = 0;
-    forAll(numLayers, patchI)
-    {
-        if (numLayers[patchI] > 0)
-        {
-            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;
-
-        {
-            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(layerParams, motionDict, nInitErrors, meshMover);
-        }
-
-        // Write mesh.
-        writeMesh("Layer mesh");
-    }
-}
-
-
 void Foam::autoHexMeshDriver::doMesh()
 {
     Switch wantRefine(dict_.lookup("doRefine"));
@@ -1884,7 +491,21 @@ void Foam::autoHexMeshDriver::doMesh()
 
     if (wantRefine)
     {
-        doRefine(dict_, wantSnap);
+        autoRefineDriver refineDriver
+        (
+            meshRefinerPtr_(),
+            decomposerPtr_(),
+            distributorPtr_(),
+            globalToPatch_
+        );
+
+        // Get all the refinement specific params
+        refinementParameters refineParams(dict_, 1);
+
+        refineDriver.doRefine(dict_, refineParams, wantSnap);
+
+        // Write mesh
+        writeMesh("Refined mesh");
     }
 
     if (wantSnap)
@@ -1892,15 +513,54 @@ void Foam::autoHexMeshDriver::doMesh()
         const dictionary& snapDict = dict_.subDict("snapDict");
         const dictionary& motionDict = dict_.subDict("motionDict");
 
-        doSnap(snapDict, motionDict);
+        autoSnapDriver snapDriver
+        (
+            meshRefinerPtr_(),
+            globalToPatch_
+        );
+
+        // Get all the snapping specific params
+        snapParameters snapParams(snapDict, 1);
+
+        snapDriver.doSnap(snapDict, motionDict, snapParams);
+
+        // Write mesh.
+        writeMesh("Snapped mesh");
     }
 
     if (wantLayers)
     {
         const dictionary& motionDict = dict_.subDict("motionDict");
         const dictionary& shrinkDict = dict_.subDict("shrinkDict");
+        PtrList<dictionary> surfaceDicts(dict_.lookup("surfaces"));
 
-        doLayers(shrinkDict, motionDict);
+        autoLayerDriver layerDriver
+        (
+            meshRefinerPtr_(),
+            globalToPatch_
+        );
+
+        // Get all the layer specific params
+        layerParameters layerParams
+        (
+            surfaceDicts,
+            surfacesPtr_(),
+            globalToPatch_,
+            shrinkDict,
+            mesh_.boundaryMesh()
+        );
+
+        layerDriver.doLayers
+        (
+            shrinkDict,
+            motionDict,
+            layerParams,
+            decomposerPtr_(),
+            distributorPtr_()
+        );
+
+        // Write mesh.
+        writeMesh("Layer mesh");
     }
 }
 
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
index 06d377a277..553f1690b8 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H
@@ -30,10 +30,6 @@ Description
 
 SourceFiles
     autoHexMeshDriver.C
-    autoHexMeshDriverSnap.C
-    autoHexMeshDriverLayers.C
-    autoHexMeshDriverShrink.C
-    autoHexMeshDriverTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -44,11 +40,7 @@ SourceFiles
 #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 "searchableSurfaces.H"
 #include "refinementSurfaces.H"
 #include "shellSurfaces.H"
@@ -63,17 +55,6 @@ namespace Foam
 
 // Class forward declarations
 class fvMesh;
-class pointMesh;
-class motionSmoother;
-class removePoints;
-class pointSet;
-class pointData;
-class faceSet;
-class addPatchCellLayer;
-class mapDistributePolyMesh;
-class snapParameters;
-class layerParameters;
-class refinementParameters;
 
 /*---------------------------------------------------------------------------*\
                            Class autoHexMeshDriver Declaration
@@ -147,13 +128,6 @@ class autoHexMeshDriver
         const scalar mergeDist_;
 
 
-        // Refinement only
-
-            //- Explicit features
-            PtrList<featureEdgeMesh> featureMeshes_;
-            //- Per feature the refinement level
-            labelList featureLevels_;
-
         //- All surface based geometry
         autoPtr<searchableSurfaces> allGeometryPtr_;
 
@@ -179,436 +153,10 @@ class autoHexMeshDriver
 
     // Private Member Functions
 
-        // Refinement
-
-            //- Calculate merge distance. Check against writing tolerance.
-            scalar getMergeDistance(const scalar mergeTol) const;
-
-            static void orientOutside(PtrList<searchableSurface>&);
-
-            //- Read feature edges
-            label readFeatureEdges(const PtrList<dictionary>&);
-
-        // 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& patchToNLayers,
-                    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
-                //  Gets per patch parameters and determine pp pointwise
-                //  parameters.
-                void calculateLayerThickness
-                (
-                    const indirectPrimitivePatch& pp,
-                    const labelList& patchIDs,
-                    const scalarField& patchExpansionRatio,
-                    const scalarField& patchFinalLayerRatio,
-                    const scalarField& patchRelMinThickness,
-                    const labelList& cellLevel,
-                    const labelList& patchNLayers,
-                    const scalar edge0Len,
-
-                    scalarField& thickness,
-                    scalarField& minThickness,
-                    scalarField& expansionRatio
-                ) 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;
+        //- Calculate merge distance. Check against writing tolerance.
+        scalar getMergeDistance(const scalar mergeTol) const;
 
+        //static void orientOutside(PtrList<searchableSurface>&);
 
         //- Disallow default bitwise copy construct
         autoHexMeshDriver(const autoHexMeshDriver&);
@@ -624,22 +172,11 @@ public:
 
     // Constructors
 
-//        //- Construct from dictionary and mesh to modify
-//        autoHexMeshDriver
-//        (
-//            fvMesh& mesh,
-//            const dictionary& meshDict,
-//            const dictionary& decomposeDict
-//        );
-
-        //- Alternative constructor from top-level controldictionary and
-        //  refinement specific dictionary
+        //- Construct from dictionary and mesh to modify
         autoHexMeshDriver
         (
             fvMesh& mesh,
-            const dictionary& controlDict,
-            const dictionary& geometryDict,
-            const dictionary& refineDict,
+            const dictionary& meshDict,
             const dictionary& decomposeDict
         );
 
@@ -677,181 +214,11 @@ public:
             }
 
 
-        // Refinement
-
-            //- Refine around explicit feature edges
-            label featureEdgeRefine
-            (
-                const refinementParameters& refineParams,
-                const PtrList<dictionary>& featDicts,
-                const label maxIter,
-                const label minRefine
-            );
-
-            //- Refine at surface intersections
-            label surfaceOnlyRefine
-            (
-                const refinementParameters& refineParams,
-                const label maxIter
-            );
-
-            //- Remove cells not reachable from keep points
-            void removeInsideCells
-            (    
-                const refinementParameters& refineParams,
-                const label nBufferLayers
-            );
-
-            //- Refine volume regions (interior of shells)
-            label shellRefine
-            (
-                const refinementParameters& refineParams,
-                const label maxIter
-            );
-
-            //- Introduce baffles; remove unreachable mesh parts
-            //  handleSnapProblems : whether to remove free floating cells
-            void baffleAndSplitMesh
-            (
-                const refinementParameters& refineParams,
-                const bool handleSnapProblems
-            );
-
-            //- Move cells to zones
-            void zonify(const refinementParameters&);
-
-            //- Split and recombine baffles to get rid of single face baffles.
-            void splitAndMergeBaffles
-            (
-                const refinementParameters& refineParams,
-                const bool handleSnapProblems
-            );
-
-            //- Merge multiple boundary faces on single cell
-            void mergePatchFaces(const refinementParameters&);
-
-            //- 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
-            );
+        // Meshing
 
             //- 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 snapParameters& snapParams,
-                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 snapParameters& snapParams,
-                const label nInitErrors,
-                const List<labelPair>& baffles,
-                motionSmoother&
-            ) const;
-
-            //- Get points both on patch and facezone.
-            labelList getZoneSurfacePoints
-            (
-                const indirectPrimitivePatch&,
-                const word& zoneName
-            ) 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
-            (
-                const snapParameters& snapParams,
-                motionSmoother&
-            ) const;
-
-            //- Do the hard work: move the mesh according to displacement,
-            //  locally relax the displacement.
-            void scaleMesh
-            (
-                const snapParameters& snapParams,
-                const label nInitErrors,
-                const List<labelPair>& baffles,
-                motionSmoother&
-            );
-
-
-        // Layers
-
-            //- Merge patch faces on same cell.
-            void mergePatchFacesUndo
-            (
-                const layerParameters& layerParams,
-                const dictionary& motionDict
-            );
-
-            //- Check that mesh outside is not multiply connected.
-            void checkMeshManifold() const;
-
-            //- Add cell layers
-            void addLayers
-            (
-                const layerParameters& layerParams,
-                const dictionary& motionDict,
-                const label nAllowableErrors,
-                motionSmoother&
-            );
-
-
-        // Other
-
-            //- Do all refinement.
-            void doRefine
-            (
-                const dictionary& refineDict,
-                const bool prepareForSnapping
-            );
-
-            //- Do all snapping.
-            void doSnap
-            (
-                const dictionary& snapDict,
-                const dictionary& motionDict
-            );
-
-            //- Do alllayer addition.
-            void doLayers
-            (
-                const dictionary& shrinkDict,
-                const dictionary& motionDict
-            );
-
             //- Do all : refine, snap, layers
             void doMesh();
 };
@@ -863,12 +230,6 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-#   include "autoHexMeshDriverTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
new file mode 100644
index 0000000000..7caa1af11e
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
@@ -0,0 +1,3128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "autoLayerDriver.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "meshRefinement.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"
+#include "OFstream.H"
+#include "layerParameters.H"
+#include "combineFaces.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(autoLayerDriver, 0);
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::label Foam::autoLayerDriver::mergePatchFacesUndo
+(
+    const scalar minCos,
+    const scalar concaveCos,
+    const dictionary& motionDict
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    // Patch face merging engine
+    combineFaces faceCombiner(mesh, true);
+
+    // Pick up all candidate cells on boundary
+    labelHashSet boundaryCells(mesh.nFaces()-mesh.nInternalFaces());
+
+    {
+        labelList patchIDs(meshRefinement::addedPatches(globalToPatch_));
+
+        const polyBoundaryMesh& patches = mesh.boundaryMesh();
+
+        forAll(patchIDs, i)
+        {
+            label patchI = patchIDs[i];
+
+            const polyPatch& patch = patches[patchI];
+
+            if (!patch.coupled())
+            {
+                forAll(patch, i)
+                {
+                    boundaryCells.insert(mesh.faceOwner()[patch.start()+i]);
+                }
+            }
+        }
+    }
+
+    // Get all sets of faces that can be merged
+    labelListList allFaceSets
+    (
+        faceCombiner.getMergeSets
+        (
+            minCos,
+            concaveCos,
+            boundaryCells
+        )
+    );
+
+    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
+        meshRefiner_.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);
+
+        meshRefiner_.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
+            meshRefiner_.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::autoLayerDriver::doRemovePoints
+(
+    removePoints& pointRemover,
+    const boolList& pointCanBeDeleted
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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);
+    meshRefiner_.updateMesh(map, labelList(0));
+
+    return map;
+}
+
+
+// Restore faces (which contain removed points)
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoLayerDriver::doRestorePoints
+(
+    removePoints& pointRemover,
+    const labelList& facesToRestore
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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);
+    meshRefiner_.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::autoLayerDriver::collectFaces
+(
+    const labelList& candidateFaces,
+    const labelHashSet& set
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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::autoLayerDriver::growFaceCellFace
+(
+    const labelHashSet& set
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::mergeEdgesUndo
+(
+    const scalar minCos,
+    const dictionary& motionDict
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::checkMeshManifold() const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::handleNonManifolds
+(
+    const indirectPrimitivePatch& pp,
+    const labelList& meshEdges,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::handleFeatureAngle
+(
+    const indirectPrimitivePatch& pp,
+    const labelList& meshEdges,
+    const scalar minCos,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::handleWarpedFaces
+(
+    const indirectPrimitivePatch& pp,
+    const scalar faceRatio,
+    const scalar edge0Len,
+    const labelList& cellLevel,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::handleMultiplePatchFaces
+//(
+//    const indirectPrimitivePatch& pp,
+//    pointField& patchDisp,
+//    labelList& patchNLayers,
+//    List<extrudeMode>& extrudeStatus
+//) const
+//{
+//    const fvMesh& mesh = meshRefiner_.mesh();
+//
+//    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;
+//}
+
+
+// No extrusion on faces with differing number of layers for points
+void Foam::autoLayerDriver::setNumLayers
+(
+    const labelList& patchToNLayers,
+    const labelList& patchIDs,
+    const indirectPrimitivePatch& pp,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    Info<< nl << "Handling points with inconsistent layer specification ..."
+        << endl;
+
+    // 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::autoLayerDriver::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;
+}
+
+
+void Foam::autoLayerDriver::calculateLayerThickness
+(
+    const indirectPrimitivePatch& pp,
+    const labelList& patchIDs,
+    const scalarField& patchExpansionRatio,
+    const scalarField& patchFinalLayerRatio,
+    const scalarField& patchRelMinThickness,
+    const labelList& cellLevel,
+    const labelList& patchNLayers,
+    const scalar edge0Len,
+
+    scalarField& thickness,
+    scalarField& minThickness,
+    scalarField& expansionRatio
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+    const polyBoundaryMesh& patches = mesh.boundaryMesh();
+
+    if (min(patchRelMinThickness) < 0 || max(patchRelMinThickness) > 2)
+    {
+        FatalErrorIn("calculateLayerThickness(..)")
+            << "Thickness should be factor of local undistorted cell size."
+            << " Valid values are [0..2]." << nl
+            << " minThickness:" << patchRelMinThickness
+            << exit(FatalError);
+    }
+
+
+    // 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
+        );
+    }
+
+
+    // Rework patch-wise layer parameters into minimum per point
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    expansionRatio.setSize(pp.nPoints());
+    expansionRatio = GREAT;
+    scalarField finalLayerRatio(pp.nPoints(), GREAT);
+    scalarField relMinThickness(pp.nPoints(), GREAT);
+
+    {
+        forAll(patchIDs, i)
+        {
+            label patchI = patchIDs[i];
+
+            const labelList& meshPoints = patches[patchI].meshPoints();
+
+            forAll(meshPoints, patchPointI)
+            {
+                label ppPointI = pp.meshPointMap()[meshPoints[patchPointI]];
+
+                expansionRatio[ppPointI] = min
+                (
+                    expansionRatio[ppPointI],
+                    patchExpansionRatio[patchI]
+                );
+                finalLayerRatio[ppPointI] = min
+                (
+                    finalLayerRatio[ppPointI],
+                    patchFinalLayerRatio[patchI]
+                );
+                relMinThickness[ppPointI] = min
+                (
+                    relMinThickness[ppPointI],
+                    patchRelMinThickness[patchI]
+                );
+            }
+        }
+
+        syncTools::syncPointList
+        (
+            mesh,
+            pp.meshPoints(),
+            expansionRatio,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+        syncTools::syncPointList
+        (
+            mesh,
+            pp.meshPoints(),
+            finalLayerRatio,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+        syncTools::syncPointList
+        (
+            mesh,
+            pp.meshPoints(),
+            relMinThickness,
+            minEqOp<scalar>(),
+            GREAT,              // null value
+            false               // no separation
+        );
+    }
+
+
+
+    // Per mesh point the expansion parameters
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    thickness.setSize(pp.nPoints());
+    minThickness.setSize(pp.nPoints());
+
+    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[pointI] == 1)
+        {
+            thickness[pointI] =
+                finalLayerRatio[pointI]
+              * patchNLayers[pointI]
+              * edgeLen;
+            minThickness[pointI] = relMinThickness[pointI]*edgeLen;
+        }
+        else
+        {
+            scalar invExpansion = 1.0 / expansionRatio[pointI];
+            label nLay = patchNLayers[pointI];
+            thickness[pointI] =
+                finalLayerRatio[pointI]
+              * edgeLen
+              * (1.0 - pow(invExpansion, nLay))
+              / (1.0 - invExpansion);
+            minThickness[pointI] = relMinThickness[pointI]*edgeLen;
+        }
+    }
+
+    Info<< "calculateLayerThickness : min:" << gMin(thickness)
+        << " max:" << gMax(thickness) << endl;
+}
+
+
+// Synchronize displacement among coupled patches.
+void Foam::autoLayerDriver::syncPatchDisplacement
+(
+    const motionSmoother& meshMover,
+    const scalarField& minThickness,
+    pointField& patchDisp,
+    labelList& patchNLayers,
+    List<extrudeMode>& extrudeStatus
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+    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::autoLayerDriver::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 fvMesh& mesh = meshRefiner_.mesh();
+    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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::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::autoLayerDriver::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;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::autoLayerDriver::autoLayerDriver
+(
+    meshRefinement& meshRefiner,
+    const labelList& globalToPatch
+)
+:
+    meshRefiner_(meshRefiner),
+    globalToPatch_(globalToPatch)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::autoLayerDriver::mergePatchFacesUndo
+(
+    const layerParameters& layerParams,
+    const dictionary& motionDict
+)
+{
+    scalar minCos = Foam::cos
+    (
+        layerParams.featureAngle()
+      * mathematicalConstant::pi/180.0
+    );
+
+    scalar concaveCos = Foam::cos
+    (
+        layerParams.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 < " << layerParams.featureAngle()
+        << " degrees"
+        << nl
+        << "      (cos:" << minCos << ')' << nl
+        << "    - as long as the resulting face doesn't become concave"
+        << " by more than "
+        << layerParams.concaveAngle()
+        << " degrees (0=straight, 180=fully concave)" << nl
+        << endl;
+
+    label nChanged = mergePatchFacesUndo(minCos, concaveCos, motionDict);
+
+    nChanged += mergeEdgesUndo(minCos, motionDict);
+}
+
+
+void Foam::autoLayerDriver::addLayers
+(
+    const layerParameters& layerParams,
+    const dictionary& motionDict,
+    const label nAllowableErrors,
+    motionSmoother& meshMover,
+    decompositionMethod& decomposer,
+    fvMeshDistribute& distributor
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+    const indirectPrimitivePatch& pp = meshMover.patch();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Precalculate mesh edge labels for patch edges
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    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
+    (
+        layerParams.numLayers(),    // per patch the num layers
+        meshMover.adaptPatchIDs(),  // patches that are being moved
+        pp,                         // indirectpatch for all faces moving
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on non-manifold points
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    handleNonManifolds
+    (
+        pp,
+        meshEdges,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on feature angles
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    handleFeatureAngle
+    (
+        pp,
+        meshEdges,
+        layerParams.featureAngle()*mathematicalConstant::pi/180.0,
+
+        patchDisp,
+        patchNLayers,
+        extrudeStatus
+    );
+
+    // Disable extrusion on warped faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // Undistorted edge length
+    const scalar edge0Len = meshRefiner_.meshCutter().level0EdgeLength();
+    const labelList& cellLevel = meshRefiner_.meshCutter().cellLevel();
+
+    handleWarpedFaces
+    (
+        pp,
+        layerParams.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 < layerParams.nGrow(); i++)
+    {
+        growNoExtrusion
+        (
+            pp,
+            patchDisp,
+            patchNLayers,
+            extrudeStatus
+        );
+    }
+
+    // Determine (wanted) point-wise layer thickness and expansion ratio
+    scalarField thickness(pp.nPoints());
+    scalarField minThickness(pp.nPoints());
+    scalarField expansionRatio(pp.nPoints());
+    calculateLayerThickness
+    (
+        pp,
+        meshMover.adaptPatchIDs(),
+        layerParams.expansionRatio(),
+        layerParams.finalLayerRatio(),
+        layerParams.minThickness(),
+        cellLevel,
+        patchNLayers,
+        edge0Len,
+
+        thickness,
+        minThickness,
+        expansionRatio
+    );
+
+    // 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,
+        layerParams.nSmoothNormals(),
+        layerParams.nSmoothSurfaceNormals(),
+        layerParams.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
+            //    layerParams.nSmoothDisp(),
+            //    layerParams.nSnap()
+            //);
+
+            // Medial axis based shrinking
+            shrinkMeshMedialDistance
+            (
+                meshMover,
+
+                layerParams.nSmoothThickness(),
+                layerParams.maxThicknessToMedialRatio(),
+                nAllowableErrors,
+                layerParams.nSnap(),
+                layerParams.layerTerminationCos(),
+
+                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,
+            layerParams.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[i] == 1.0)
+                {
+                    firstDisp[i] = patchDisp[i]/nPatchPointLayers[i];
+                }
+                else
+                {
+                    label nLay = nPatchPointLayers[i];
+                    scalar h =
+                        pow(expansionRatio[i], nLay - 1)
+                      * (mag(patchDisp[i])*(1.0 - expansionRatio[i]))
+                      / (1.0 - pow(expansionRatio[i], nLay));
+                    firstDisp[i] = h/mag(patchDisp[i])*patchDisp[i];
+                }
+            }
+        }
+
+        scalarField 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.name() << endl;
+            addedCellSet.write();
+
+            faceSet layerFacesSet
+            (
+                newMesh,
+                "layerFaces",
+                findIndices(flaggedCells, true)
+            );
+            Info<< "Writing "
+                << returnReduce(layerFacesSet.size(), sumOp<label>())
+                << " faces inside added layer to faceSet "
+                << layerFacesSet.name() << endl;
+            layerFacesSet.write();
+        }
+
+        // Unset the extrusion at the pp.
+        label nTotChanged = checkAndUnmark
+        (
+            addLayer,
+            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());
+    }
+
+    meshRefiner_.updateMesh(map, labelList(0));
+
+
+    // Do final balancing
+    // ~~~~~~~~~~~~~~~~~~
+
+    if (Pstream::parRun())
+    {
+        Info<< nl
+            << "Doing final balancing" << nl
+            << "---------------------" << nl
+            << endl;
+
+        if (debug)
+        {
+            const_cast<Time&>(mesh.time())++;
+        }
+
+        // Balance. No restriction on face zones and baffles.
+        autoPtr<mapDistributePolyMesh> map = meshRefiner_.balance
+        (
+            false,
+            false,
+            decomposer,
+            distributor
+        );
+
+        // Re-distribute flag of layer faces and cells
+        map().distributeCellData(flaggedCells);
+        map().distributeFaceData(flaggedFaces);
+    }
+
+
+    // Write mesh
+    // ~~~~~~~~~~
+
+    cellSet addedCellSet(mesh, "addedCells", findIndices(flaggedCells, true));
+    Info<< "Writing "
+        << returnReduce(addedCellSet.size(), sumOp<label>())
+        << " added cells to cellSet "
+        << addedCellSet.name() << endl;
+    addedCellSet.write();
+
+    faceSet layerFacesSet(mesh, "layerFaces", findIndices(flaggedFaces, true));
+    Info<< "Writing "
+        << returnReduce(layerFacesSet.size(), sumOp<label>())
+        << " faces inside added layer to faceSet "
+        << layerFacesSet.name() << endl;
+    layerFacesSet.write();
+}
+
+
+void Foam::autoLayerDriver::doLayers
+(
+    const dictionary& shrinkDict,
+    const dictionary& motionDict,
+    const layerParameters& layerParams,
+    decompositionMethod& decomposer,
+    fvMeshDistribute& distributor
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    Info<< nl
+        << "Shrinking and layer addition phase" << nl
+        << "----------------------------------" << nl
+        << endl;
+
+    const_cast<Time&>(mesh.time())++;
+
+    Info<< "Using mesh parameters " << motionDict << nl << endl;
+
+    // Merge coplanar boundary faces
+    mergePatchFacesUndo(layerParams, motionDict);
+
+    // Per patch the number of layers (0 if no layer)
+    const labelList& numLayers = layerParams.numLayers();
+
+    // Patches that need to get a layer
+    DynamicList<label> patchIDs(numLayers.size());
+    label nFacesWithLayers = 0;
+    forAll(numLayers, patchI)
+    {
+        if (numLayers[patchI] > 0)
+        {
+            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;
+
+        {
+            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
+            (
+                layerParams,
+                motionDict,
+                nInitErrors,
+                meshMover,
+                decomposer,
+                distributor
+            );
+        }
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
new file mode 100644
index 0000000000..af768a64aa
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
@@ -0,0 +1,562 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::autoLayerDriver
+
+Description
+    All to do with adding layers
+
+SourceFiles
+    autoLayerDriver.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef autoLayerDriver_H
+#define autoLayerDriver_H
+
+#include "meshRefinement.H"
+#include "wallPoint.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class removePoints;
+class pointSet;
+class motionSmoother;
+class addPatchCellLayer;
+class pointData;
+class wallPoint;
+class faceSet;
+class layerParameters;
+
+/*---------------------------------------------------------------------------*\
+                           Class autoLayerDriver Declaration
+\*---------------------------------------------------------------------------*/
+
+class autoLayerDriver
+{
+    // Static data members
+
+        //- 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 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
+
+        //- Mesh+surface
+        meshRefinement& meshRefiner_;
+
+        //- From surface region to patch
+        const labelList globalToPatch_;
+
+
+
+    // Private Member Functions
+
+
+        // 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
+            );
+
+            //- Check that mesh outside is not multiply connected.
+            void checkMeshManifold() const;
+
+
+            // 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& patchToNLayers,
+                    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
+                //  Gets per patch parameters and determine pp pointwise
+                //  parameters.
+                void calculateLayerThickness
+                (
+                    const indirectPrimitivePatch& pp,
+                    const labelList& patchIDs,
+                    const scalarField& patchExpansionRatio,
+                    const scalarField& patchFinalLayerRatio,
+                    const scalarField& patchRelMinThickness,
+                    const labelList& cellLevel,
+                    const labelList& patchNLayers,
+                    const scalar edge0Len,
+
+                    scalarField& thickness,
+                    scalarField& minThickness,
+                    scalarField& expansionRatio
+                ) 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>
+                static void averageNeighbours
+                (
+                    const polyMesh& mesh,
+                    const PackedList<1>& isMasterEdge,
+                    const labelList& meshEdges,
+                    const labelList& meshPoints,
+                    const edgeList& edges,
+                    const scalarField& invSumWeight,
+                    const Field<Type>& data,
+                    Field<Type>& average
+                );
+
+                //- 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
+        autoLayerDriver(const autoLayerDriver&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const autoLayerDriver&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("autoLayerDriver");
+
+    // Constructors
+
+        //- Construct from components
+        autoLayerDriver
+        (
+            meshRefinement& meshRefiner,
+            const labelList& globalToPatch
+        );
+
+
+    // Member Functions
+
+            //- Merge patch faces on same cell.
+            void mergePatchFacesUndo
+            (
+                const layerParameters& layerParams,
+                const dictionary& motionDict
+            );
+
+            //- Add cell layers
+            void addLayers
+            (
+                const layerParameters& layerParams,
+                const dictionary& motionDict,
+                const label nAllowableErrors,
+                motionSmoother& meshMover,
+                decompositionMethod& decomposer,
+                fvMeshDistribute& distributor
+            );
+
+            //- Add layers according to the dictionary settings
+            void doLayers
+            (
+                const dictionary& shrinkDict,
+                const dictionary& motionDict,
+                const layerParameters& layerParams,
+                decompositionMethod& decomposer,
+                fvMeshDistribute& distributor
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "autoLayerDriverTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
new file mode 100644
index 0000000000..8c41371ddc
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
@@ -0,0 +1,1159 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "autoLayerDriver.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::autoLayerDriver::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
+    (
+        meshRefiner_.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::autoLayerDriver::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
+        (
+            meshMover.mesh(),
+            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::autoLayerDriver::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
+        (
+            meshMover.mesh(),
+            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::autoLayerDriver::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 fvMesh& mesh = meshRefiner_.mesh();
+    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
+        (
+            mesh,
+            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::autoLayerDriver::isMaxEdge
+(
+    const List<pointData>& pointWallDist,
+    const label edgeI,
+    const scalar minCos
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+    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::autoLayerDriver::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::autoLayerDriver::findIsolatedRegions
+(
+    const indirectPrimitivePatch& pp,
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const scalar minCosLayerTermination,
+    scalarField& field,
+    List<extrudeMode>& extrudeStatus,
+    pointField& patchDisp,
+    labelList& patchNLayers
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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::autoLayerDriver::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 polyMesh& mesh = meshMover.mesh();
+    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::autoLayerDriver::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/autoLayerDriverTemplates.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverTemplates.C
new file mode 100644
index 0000000000..7284b4a355
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverTemplates.C
@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "autoLayerDriver.H"
+#include "syncTools.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::autoLayerDriver::averageNeighbours
+(
+    const polyMesh& mesh,
+    const PackedList<1>& isMasterEdge,
+    const labelList& meshEdges,
+    const labelList& meshPoints,
+    const edgeList& edges,
+    const scalarField& invSumWeight,
+    const Field<Type>& data,
+    Field<Type>& average
+)
+{
+    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/autoRefineDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
new file mode 100644
index 0000000000..218087f774
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
@@ -0,0 +1,776 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "autoRefineDriver.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "boundBox.H"
+#include "mapDistributePolyMesh.H"
+#include "cellSet.H"
+#include "syncTools.H"
+#include "refinementParameters.H"
+#include "featureEdgeMesh.H"
+#include "refinementSurfaces.H"
+#include "shellSurfaces.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(autoRefineDriver, 0);
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Read explicit feature edges
+Foam::label Foam::autoRefineDriver::readFeatureEdges
+(
+    const PtrList<dictionary>& featDicts,
+    PtrList<featureEdgeMesh>& featureMeshes,
+    labelList& featureLevels
+) const
+{
+    Info<< "Reading external feature lines." << endl;
+
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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(meshRefiner_.mergeDistance());
+        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" << nl << endl;
+
+    return featureMeshes.size();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+Foam::autoRefineDriver::autoRefineDriver
+(
+    meshRefinement& meshRefiner,
+    decompositionMethod& decomposer,
+    fvMeshDistribute& distributor,
+    const labelList& globalToPatch
+)
+:
+    meshRefiner_(meshRefiner),
+    decomposer_(decomposer),
+    distributor_(distributor),
+    globalToPatch_(globalToPatch)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::label Foam::autoRefineDriver::featureEdgeRefine
+(
+    const refinementParameters& refineParams,
+    const PtrList<dictionary>& featDicts,
+    const label maxIter,
+    const label minRefine
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // Read explicit feature edges
+    PtrList<featureEdgeMesh> featureMeshes;
+    // Per feature the refinement level
+    labelList featureLevels;
+    readFeatureEdges(featDicts, featureMeshes, featureLevels);
+
+
+    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
+                (
+                    refineParams.keepPoints()[0],    // For now only use one.
+                    refineParams.curvature(),
+
+                    featureMeshes,
+                    featureLevels,
+
+                    true,               // featureRefinement
+                    false,              // internalRefinement
+                    false,              // surfaceRefinement
+                    false,              // curvatureRefinement
+                    refineParams.maxGlobalCells(),
+                    refineParams.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),
+                decomposer_,
+                distributor_,
+                cellsToRefine
+            );
+        }
+    }
+    return iter;
+}
+
+
+Foam::label Foam::autoRefineDriver::surfaceOnlyRefine
+(
+    const refinementParameters& refineParams,
+    const label maxIter
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // Determine the maximum refinement level over all surfaces. This
+    // determines the minumum number of surface refinement iterations.
+    label overallMaxLevel = max(meshRefiner_.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
+            (
+                refineParams.keepPoints()[0],
+                refineParams.curvature(),
+
+                PtrList<featureEdgeMesh>(0),    // dummy featureMeshes;
+                labelList(0),                   // dummy featureLevels;
+
+                false,              // featureRefinement
+                false,              // internalRefinement
+                true,               // surfaceRefinement
+                true,               // curvatureRefinement
+                refineParams.maxGlobalCells(),
+                refineParams.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 <= refineParams.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),
+            decomposer_,
+            distributor_,
+            cellsToRefine
+        );
+    }
+    return iter;
+}
+
+
+void Foam::autoRefineDriver::removeInsideCells
+(
+    const refinementParameters& refineParams,
+    const label nBufferLayers
+)
+{
+    Info<< nl
+        << "Removing mesh beyond surface intersections" << nl
+        << "------------------------------------------" << nl
+        << endl;
+
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    if (debug)
+    {
+       const_cast<Time&>(mesh.time())++;
+    }
+
+    meshRefiner_.splitMesh
+    (
+        nBufferLayers,                  // nBufferLayers
+        globalToPatch_,
+        refineParams.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::autoRefineDriver::shellRefine
+(
+    const refinementParameters& refineParams,
+    const label maxIter
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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 = meshRefiner_.shells().maxLevel();
+
+    label iter;
+    for (iter = 0; iter < maxIter; iter++)
+    {
+        Info<< nl
+            << "Shell refinement iteration " << iter << nl
+            << "----------------------------" << nl
+            << endl;
+
+        labelList candidateCells
+        (
+            meshRefiner_.refineCandidates
+            (
+                refineParams.keepPoints()[0],
+                refineParams.curvature(),
+
+                PtrList<featureEdgeMesh>(0),    // dummy featureMeshes;
+                labelList(0),                   // dummy featureLevels;
+
+                false,              // featureRefinement
+                true,               // internalRefinement
+                false,              // surfaceRefinement
+                false,              // curvatureRefinement
+                refineParams.maxGlobalCells(),
+                refineParams.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 (refineParams.nBufferLayers() <= 2)
+        {
+            cellsToRefine = meshRefiner_.meshCutter().consistentSlowRefinement
+            (
+                refineParams.nBufferLayers(),
+                candidateCells,                     // cells to refine
+                bFaces,                             // faces for nBufferLayers
+                1,                                  // point difference
+                meshRefiner_.intersectedPoints()    // points to check
+            );
+        }
+        else
+        {
+            cellsToRefine = meshRefiner_.meshCutter().consistentSlowRefinement2
+            (
+                refineParams.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 <= refineParams.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),
+            decomposer_,
+            distributor_,
+            cellsToRefine
+        );
+    }
+    meshRefiner_.userFaceData().clear();
+
+    return iter;
+}
+
+
+void Foam::autoRefineDriver::baffleAndSplitMesh
+(
+    const refinementParameters& refineParams,
+    const bool handleSnapProblems
+)
+{
+    Info<< nl
+        << "Splitting mesh at surface intersections" << nl
+        << "---------------------------------------" << nl
+        << endl;
+
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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_,
+        refineParams.keepPoints()[0]
+    );
+}
+
+
+void Foam::autoRefineDriver::zonify
+(
+    const refinementParameters& refineParams
+)
+{
+    // 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.
+
+    if (meshRefiner_.surfaces().getNamedSurfaces().size() > 0)
+    {
+        Info<< nl
+            << "Introducing zones for interfaces" << nl
+            << "--------------------------------" << nl
+            << endl;
+
+        const fvMesh& mesh = meshRefiner_.mesh();
+
+        if (debug)
+        {
+            const_cast<Time&>(mesh.time())++;
+        }
+
+        meshRefiner_.zonify(refineParams.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
+        meshRefinement::checkCoupledFaceZones(mesh);
+    }
+}
+
+
+void Foam::autoRefineDriver::splitAndMergeBaffles
+(
+    const refinementParameters& refineParams,
+    const bool handleSnapProblems
+)
+{
+    Info<< nl
+        << "Handling cells with snap problems" << nl
+        << "---------------------------------" << nl
+        << endl;
+
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // Introduce baffles and split mesh
+    if (debug)
+    {
+        const_cast<Time&>(mesh.time())++;
+    }
+
+    meshRefiner_.baffleAndSplitMesh
+    (
+        handleSnapProblems,
+        false,                  // merge free standing baffles?
+        const_cast<Time&>(mesh.time()),
+        globalToPatch_,
+        refineParams.keepPoints()[0]
+    );
+
+    if (debug)
+    {
+        const_cast<Time&>(mesh.time())++;
+    }
+
+    // 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::autoRefineDriver::mergePatchFaces
+(
+    const refinementParameters& refineParams
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    Info<< nl
+        << "Merge refined boundary faces" << nl
+        << "----------------------------" << nl
+        << endl;
+
+    if (debug)
+    {
+        const_cast<Time&>(mesh.time())++;
+    }
+
+    meshRefiner_.mergePatchFaces
+    (
+        Foam::cos(45*mathematicalConstant::pi/180.0),
+        Foam::cos(45*mathematicalConstant::pi/180.0),
+        meshRefinement::addedPatches(globalToPatch_)
+    );
+
+    if (debug)
+    {
+        meshRefiner_.checkData();
+    }
+
+    meshRefiner_.mergeEdges(Foam::cos(45*mathematicalConstant::pi/180.0));
+
+    if (debug)
+    {
+        meshRefiner_.checkData();
+    }
+}
+
+
+void Foam::autoRefineDriver::doRefine
+(
+    const dictionary& refineDict,
+    const refinementParameters& refineParams,
+    const bool prepareForSnapping
+)
+{
+    Info<< nl
+        << "Refinement phase" << nl
+        << "----------------" << nl
+        << endl;
+
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    const_cast<Time&>(mesh.time())++;
+
+
+    // Check that all the keep points are inside the mesh.
+    refineParams.findCells(mesh);
+
+    PtrList<dictionary> featDicts(refineDict.lookup("features"));
+
+    // Refine around feature edges
+    featureEdgeRefine
+    (
+        refineParams,
+        featDicts,
+        100,    // maxIter
+        0       // min cells to refine
+    );
+
+    // Refine based on surface
+    surfaceOnlyRefine
+    (
+        refineParams,
+        100     // maxIter
+    );
+
+    // Remove cells (a certain distance) beyond surface intersections
+    removeInsideCells
+    (
+        refineParams,
+        1       // nBufferLayers
+    );
+
+    // Internal mesh refinement
+    shellRefine
+    (
+        refineParams,
+        100    // maxIter
+    );
+
+    // Introduce baffles at surface intersections
+    baffleAndSplitMesh(refineParams, prepareForSnapping);
+
+    // Mesh is at its finest. Do optional zoning.
+    zonify(refineParams);
+
+    // Pull baffles apart
+    splitAndMergeBaffles(refineParams, prepareForSnapping);
+
+    // Do something about cells with refined faces on the boundary
+    if (prepareForSnapping)
+    {
+        mergePatchFaces(refineParams);
+    }
+
+
+    if (Pstream::parRun())
+    {
+        Info<< nl
+            << "Doing final balancing" << nl
+            << "---------------------" << nl
+            << endl;
+
+        if (debug)
+        {
+            const_cast<Time&>(mesh.time())++;
+        }
+
+        // Do final balancing. Keep zoned faces on one processor.
+        meshRefiner_.balance
+        (
+            true,
+            false,
+            decomposer_,
+            distributor_
+        );
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
new file mode 100644
index 0000000000..8aa33855de
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
@@ -0,0 +1,179 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::autoRefineDriver
+
+Description
+
+SourceFiles
+    autoRefineDriver.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef autoRefineDriver_H
+#define autoRefineDriver_H
+
+#include "meshRefinement.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class featureEdgeMesh;
+class refinementParameters;
+
+
+/*---------------------------------------------------------------------------*\
+                           Class autoRefineDriver Declaration
+\*---------------------------------------------------------------------------*/
+
+class autoRefineDriver
+{
+    // Private data
+
+        //- Mesh+surface
+        meshRefinement& meshRefiner_;
+
+        //- Reference to decomposition method
+        decompositionMethod& decomposer_;
+
+        //- Reference to mesh distribution engine
+        fvMeshDistribute& distributor_;
+
+        //- From surface region to patch
+        const labelList globalToPatch_;
+
+
+    // Private Member Functions
+
+        //- Read explicit feature edges
+        label readFeatureEdges
+        (
+            const PtrList<dictionary>& featDicts,
+            PtrList<featureEdgeMesh>& featureMeshes,
+            labelList& featureLevel
+        ) const;
+
+        //- Refine all cells pierced by explicit feature edges
+        label featureEdgeRefine
+        (
+            const refinementParameters& refineParams,
+            const PtrList<dictionary>& featDicts,
+            const label maxIter,
+            const label minRefine
+        );
+
+        //- Refine all cells interacting with the surface
+        label surfaceOnlyRefine
+        (
+            const refinementParameters& refineParams,
+            const label maxIter
+        );
+
+        //- Remove all cells within intersected region
+        void removeInsideCells
+        (
+            const refinementParameters& refineParams,
+            const label nBufferLayers
+        );
+
+        //- Remove all cells inside/outside shell
+        label shellRefine
+        (
+            const refinementParameters& refineParams,
+            const label maxIter
+        );
+
+        //- Add baffles and remove unreachable cells
+        void baffleAndSplitMesh
+        (
+            const refinementParameters& refineParams,
+            const bool handleSnapProblems
+        );
+
+        //- Add zones
+        void zonify(const refinementParameters& refineParams);
+
+        void splitAndMergeBaffles
+        (
+            const refinementParameters& refineParams,
+            const bool handleSnapProblems
+        );
+
+        //- Merge refined boundary faces (from exposing coarser cell)
+        void mergePatchFaces
+        (
+            const refinementParameters& refineParams
+        );
+
+
+        //- Disallow default bitwise copy construct
+        autoRefineDriver(const autoRefineDriver&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const autoRefineDriver&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("autoRefineDriver");
+
+
+    // Constructors
+
+        //- Construct from components
+        autoRefineDriver
+        (
+            meshRefinement& meshRefiner,
+            decompositionMethod& decomposer,
+            fvMeshDistribute& distributor,
+            const labelList& globalToPatch
+        );
+
+
+    // Member Functions
+
+        //- Do all the refinement
+        void doRefine
+        (
+            const dictionary& refineDict,
+            const refinementParameters& refineParams,
+            const bool prepareForSnapping
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
new file mode 100644
index 0000000000..85b4f9d5d7
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
@@ -0,0 +1,1385 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 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 "autoSnapDriver.H"
+#include "Time.H"
+#include "pointFields.H"
+#include "motionSmoother.H"
+#include "polyTopoChange.H"
+#include "OFstream.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"
+#include "snapParameters.H"
+#include "refinementSurfaces.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(autoSnapDriver, 0);
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::autoSnapDriver::getZonedSurfaces
+(
+    labelList& zonedSurfaces,
+    labelList& unzonedSurfaces
+) const
+{    // Surfaces with zone information
+    const wordList& faceZoneNames = meshRefiner_.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::autoSnapDriver::getZoneBafflePatches
+(
+    const bool allowBoundary
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+    const refinementSurfaces& surfaces = meshRefiner_.surfaces();
+
+    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.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::autoSnapDriver::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::autoSnapDriver::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::autoSnapDriver::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::autoSnapDriver::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::autoSnapDriver::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;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::autoSnapDriver::autoSnapDriver
+(
+    meshRefinement& meshRefiner,
+    const labelList& globalToPatch
+)
+:
+    meshRefiner_(meshRefiner),
+    globalToPatch_(globalToPatch)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::autoSnapDriver::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)
+    {
+        fvMesh& mesh = meshRefiner_.mesh();
+
+        // 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 = meshRefiner_.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("autoSnapDriver::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::autoSnapDriver::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 = meshRefiner_.mergeBaffles(baffles);
+
+        Info<< "Converted baffles in = "
+            << meshRefiner_.mesh().time().cpuTimeIncrement()
+            << " s\n" << nl << endl;
+    }
+
+    return map;
+}
+
+
+Foam::scalarField Foam::autoSnapDriver::calcSnapDistance
+(
+    const snapParameters& snapParams,
+    const indirectPrimitivePatch& pp
+) const
+{
+    const edgeList& edges = pp.edges();
+    const labelListList& pointEdges = pp.pointEdges();
+    const pointField& localPoints = pp.localPoints();
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    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 snapParams.snapTol()*maxEdgeLen;
+}
+
+
+//// Invert globalToPatch_ to get the patches related to surfaces.
+//Foam::labelList Foam::autoSnapDriver::getSurfacePatches() const
+//{
+//    // Set of patches originating from surface
+//    labelHashSet surfacePatchSet(globalToPatch_.size());
+//
+//    forAll(globalToPatch_, i)
+//    {
+//        if (globalToPatch_[i] != -1)
+//        {
+//            surfacePatchSet.insert(globalToPatch_[i]);
+//        }
+//    }
+//
+//    const fvMesh& mesh = meshRefiner_.mesh();
+//
+//    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::autoSnapDriver::preSmoothPatch
+(
+    const snapParameters& snapParams,
+    const label nInitErrors,
+    const List<labelPair>& baffles,
+    motionSmoother& meshMover
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    labelList checkFaces;
+
+    Info<< "Smoothing patch points ..." << endl;
+    for
+    (
+        label smoothIter = 0;
+        smoothIter < snapParams.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*snapParams.nSnap(); snapIter++)
+        {
+            Info<< nl << "Scaling iteration " << snapIter << endl;
+
+            if (snapIter == snapParams.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)
+    {
+        const_cast<Time&>(mesh.time())++;
+        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;
+}
+
+
+// Get (pp-local) indices of points that are both on zone and on patched surface
+Foam::labelList Foam::autoSnapDriver::getZoneSurfacePoints
+(
+    const indirectPrimitivePatch& pp,
+    const word& zoneName
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    label zoneI = mesh.faceZones().findZoneID(zoneName);
+
+    if (zoneI == -1)
+    {
+        FatalErrorIn
+        (
+            "autoSnapDriver::getZoneSurfacePoints"
+            "(const indirectPrimitivePatch&, const word&)"
+        )   << "Cannot find zone " << zoneName
+            << exit(FatalError);
+    }
+
+    const faceZone& fZone = mesh.faceZones()[zoneI];
+
+
+    // Could use PrimitivePatch & localFaces to extract points but might just
+    // as well do it ourselves.
+
+    boolList pointOnZone(pp.nPoints(), false);
+
+    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();
+                pointOnZone[pointI] = true;
+            }
+        }
+    }
+
+    return findIndices(pointOnZone, true);
+}
+
+
+Foam::vectorField Foam::autoSnapDriver::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();
+    const refinementSurfaces& surfaces = meshRefiner_.surfaces();
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // 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
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        List<pointIndexHit> hitInfo;
+        labelList hitSurface;
+        surfaces.findNearest
+        (
+            unzonedSurfaces,
+            localPoints,
+            sqr(4*snapDist),        // sqr of attract distance
+            hitSurface,
+            hitInfo
+        );
+
+        forAll(hitInfo, pointI)
+        {
+            if (hitInfo[pointI].hit())
+            {
+                patchDisp[pointI] =
+                    hitInfo[pointI].hitPoint()
+                  - localPoints[pointI];
+            }
+            //else
+            //{
+            //   WarningIn("autoSnapDriver::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);
+
+        // Get indices of points both on faceZone and on pp.
+        labelList zonePointIndices
+        (
+            getZoneSurfacePoints
+            (
+                pp,
+                faceZoneNames[zoneSurfI]
+            )
+        );
+
+        pointField zonePoints(zonePointIndices.size());
+        forAll(zonePointIndices, i)
+        {
+            zonePoints[i] = localPoints[zonePointIndices[i]];
+        }
+
+        // Find nearest for points both on faceZone and pp.
+        List<pointIndexHit> hitInfo;
+        labelList hitSurface;
+        surfaces.findNearest
+        (
+            labelList(1, zoneSurfI),
+            zonePoints,
+            sqr(4*snapDist),
+            hitSurface,
+            hitInfo
+        );
+
+        forAll(hitInfo, pointI)
+        {
+            if (hitInfo[pointI].hit())
+            {
+                patchDisp[pointI] =
+                    hitInfo[pointI].hitPoint()
+                  - localPoints[pointI];
+            }
+            else
+            {
+                WarningIn("autoSnapDriver::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::autoSnapDriver::smoothDisplacement
+(
+    const snapParameters& snapParams,
+    motionSmoother& meshMover
+) const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+    const pointMesh& pMesh = meshMover.pMesh();
+    const indirectPrimitivePatch& pp = meshMover.patch();
+
+    Info<< "Smoothing displacement ..." << endl;
+
+    // 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 < snapParams.nSmoothDispl(); 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)
+    {
+        const_cast<Time&>(mesh.time())++;
+        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::autoSnapDriver::scaleMesh
+(
+    const snapParameters& snapParams,
+    const label nInitErrors,
+    const List<labelPair>& baffles,
+    motionSmoother& meshMover
+)
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    // Relax displacement until correct mesh
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    labelList checkFaces(identity(mesh.nFaces()));
+
+    scalar oldErrorReduction = -1;
+
+    Info<< "Moving mesh ..." << endl;
+    for (label iter = 0; iter < 2*snapParams.nSnap(); iter++)
+    {
+        Info<< nl << "Iteration " << iter << endl;
+
+        if (iter == snapParams.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)
+        {
+            const_cast<Time&>(mesh.time())++;
+            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();
+        }
+    }
+
+    if (oldErrorReduction >= 0)
+    {
+        meshMover.setErrorReduction(oldErrorReduction);
+    }
+    Info<< "Moved mesh in = "
+        << mesh.time().cpuTimeIncrement() << " s\n" << nl << endl;
+}
+
+
+void Foam::autoSnapDriver::doSnap
+(
+    const dictionary& snapDict,
+    const dictionary& motionDict,
+    const snapParameters& snapParams
+)
+{
+    fvMesh& mesh = meshRefiner_.mesh();
+
+    Info<< nl
+        << "Morphing phase" << nl
+        << "--------------" << nl
+        << endl;
+
+    const_cast<Time&>(mesh.time())++;
+
+    // Get the labels of added patches.
+    labelList adaptPatchIDs(meshRefinement::addedPatches(globalToPatch_));
+
+    // 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(snapParams, pp));
+
+
+        // Construct iterative mesh mover.
+        Info<< "Constructing mesh displacer ..." << endl;
+        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(snapParams, nInitErrors, baffles, meshMover);
+
+        // Calculate displacement at every patch point. Insert into
+        // meshMover.
+        calcNearestSurface(snapDist, meshMover);
+
+        // Get smoothly varying internal displacement field.
+        smoothDisplacement(snapParams, meshMover);
+
+        // Apply internal displacement to mesh.
+        scaleMesh(snapParams, nInitErrors, baffles, meshMover);
+    }
+
+    // Merge any introduced baffles.
+    mergeZoneBaffles(baffles);
+}
+
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
new file mode 100644
index 0000000000..82cf448b98
--- /dev/null
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::autoSnapDriver
+
+Description
+    All to do with snapping to surface
+
+SourceFiles
+    autoSnapDriver.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef autoSnapDriver_H
+#define autoSnapDriver_H
+
+#include "meshRefinement.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class motionSmoother;
+class snapParameters;
+
+/*---------------------------------------------------------------------------*\
+                           Class autoSnapDriver Declaration
+\*---------------------------------------------------------------------------*/
+
+class autoSnapDriver
+{
+    // 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;
+                }
+            }
+        };
+
+
+    // Private data
+
+        //- Mesh+surface
+        meshRefinement& meshRefiner_;
+
+        //- From surface region to patch
+        const labelList globalToPatch_;
+
+
+    // Private Member Functions
+
+
+        // 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&
+            );
+
+
+        //- Disallow default bitwise copy construct
+        autoSnapDriver(const autoSnapDriver&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const autoSnapDriver&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("autoSnapDriver");
+
+
+    // Constructors
+
+        //- Construct from components
+        autoSnapDriver
+        (
+            meshRefinement& meshRefiner,
+            const labelList& globalToPatch
+        );
+
+
+    // Member Functions
+
+        // 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 snapParameters& snapParams,
+                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 snapParameters& snapParams,
+                const label nInitErrors,
+                const List<labelPair>& baffles,
+                motionSmoother&
+            ) const;
+
+            //- Get points both on patch and facezone.
+            labelList getZoneSurfacePoints
+            (
+                const indirectPrimitivePatch&,
+                const word& zoneName
+            ) 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
+            (
+                const snapParameters& snapParams,
+                motionSmoother&
+            ) const;
+
+            //- Do the hard work: move the mesh according to displacement,
+            //  locally relax the displacement.
+            void scaleMesh
+            (
+                const snapParameters& snapParams,
+                const label nInitErrors,
+                const List<labelPair>& baffles,
+                motionSmoother&
+            );
+
+            void doSnap
+            (
+                const dictionary& snapDict,
+                const dictionary& motionDict,
+                const snapParameters& snapParams
+            );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
index 1d3a18714a..a2fd5ca976 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
@@ -27,22 +27,136 @@ License
 #include "layerParameters.H"
 #include "polyBoundaryMesh.H"
 #include "mathematicalConstants.H"
+#include "refinementSurfaces.H"
+#include "searchableSurfaces.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 const Foam::scalar Foam::layerParameters::defaultConcaveAngle = 90;
 
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Read the number of layers from dictionary. Per patch 0 or the number
+// of layers.
+Foam::labelList Foam::layerParameters::readNumLayers
+(
+    const PtrList<dictionary>& surfaceDicts,
+    const refinementSurfaces& refineSurfaces,
+    const labelList& globalToPatch,
+    const polyBoundaryMesh& boundaryMesh
+)
+{
+    // Per surface the number of layers
+    labelList globalSurfLayers(surfaceDicts.size());
+    // Per surface, per region the number of layers
+    List<Map<label> > regionSurfLayers(surfaceDicts.size());
+
+    const labelList& surfaceIndices = refineSurfaces.surfaces();
+
+    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"));
+
+            const wordList& regionNames =
+                refineSurfaces.geometry()[surfaceIndices[surfI]].regions();
+
+            forAll(regionDicts, dictI)
+            {
+                const dictionary& regionDict = regionDicts[dictI];
+
+                const word regionName(regionDict.lookup("name"));
+
+                label regionI = findIndex(regionNames, regionName);
+
+                label nLayers = readLabel(regionDict.lookup("surfaceLayers"));
+
+                Info<< "    region " << regionName << ':'<< nl
+                    << "        surface layers:" << nLayers << nl;
+
+                regionSurfLayers[surfI].insert(regionI, nLayers);
+            }
+        }
+    }
+
+
+    // Transfer per surface/region information into patchwise region info
+
+    labelList nLayers(boundaryMesh.size(), 0);
+
+    forAll(surfaceIndices, surfI)
+    {
+        const wordList& regionNames =
+            refineSurfaces.geometry()[surfaceIndices[surfI]].regions();
+
+        forAll(regionNames, regionI)
+        {
+            const word& regionName = regionNames[regionI];
+
+            label global = refineSurfaces.globalRegion(surfI, regionI);
+
+            label patchI = globalToPatch[global];
+
+            // Initialise to surface-wise layers
+            nLayers[patchI] = globalSurfLayers[surfI];
+
+            // Override with region specific data if available
+            Map<label>::const_iterator iter =
+                regionSurfLayers[surfI].find(regionI);
+
+            if (iter != regionSurfLayers[surfI].end())
+            {
+                nLayers[patchI] = iter();
+            }
+
+            // Check
+            if (nLayers[patchI] < 0)
+            {
+                FatalErrorIn
+                (
+                    "layerParameters::readNumLayers(..)"
+                )   << "Illegal number of layers " << nLayers[patchI]
+                    << " for surface "
+                    << refineSurfaces.names()[surfI]
+                    << " region " << regionName << endl
+                    << exit(FatalError);
+            }
+        }
+    }
+    return nLayers;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct from dictionary
 Foam::layerParameters::layerParameters
 (
+    const PtrList<dictionary>& surfaceDicts,
+    const refinementSurfaces& refineSurfaces,
+    const labelList& globalToPatch,
     const dictionary& dict,
-    const labelList& numLayers
+    const polyBoundaryMesh& boundaryMesh
 )
 :
-    numLayers_(numLayers),
+    numLayers_
+    (
+        readNumLayers
+        (
+            surfaceDicts,
+            refineSurfaces,
+            globalToPatch,
+            boundaryMesh
+        )
+    ),
     expansionRatio_
     (
         numLayers_.size(),
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
index 9c16e27116..2e391328e1 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
@@ -47,6 +47,7 @@ namespace Foam
 
 // Class forward declarations
 class polyBoundaryMesh;
+class refinementSurfaces;
 
 /*---------------------------------------------------------------------------*\
                            Class layerParameters Declaration
@@ -107,6 +108,15 @@ class layerParameters
 
     // Private Member Functions
 
+        //- Extract patch-wise number of layers
+        static labelList readNumLayers
+        (
+            const PtrList<dictionary>& surfaceDicts,
+            const refinementSurfaces& refineSurfaces,
+            const labelList& globalToPatch,
+            const polyBoundaryMesh& boundaryMesh
+        );
+
         //- Disallow default bitwise copy construct
         layerParameters(const layerParameters&);
 
@@ -119,7 +129,14 @@ public:
     // Constructors
 
         //- Construct from dictionary - old syntax
-        layerParameters(const dictionary& dict, const labelList& numLayers);
+        layerParameters
+        (
+            const PtrList<dictionary>& surfaceDicts,
+            const refinementSurfaces& refineSurfaces,
+            const labelList& globalToPatch,
+            const dictionary& dict,
+            const polyBoundaryMesh& boundaryMesh
+        );
 
         //- Construct from dictionary - new syntax
         layerParameters(const dictionary& dict, const polyBoundaryMesh&);
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
index a60e7758da..4fe3005766 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -224,7 +224,7 @@ void Foam::meshRefinement::checkData()
         // Compare
         testSyncBoundaryFaceList
         (
-            tol_,
+            mergeDistance_,
             "testing faceCentres : ",
             boundaryFc,
             neiBoundaryFc
@@ -489,13 +489,13 @@ void Foam::meshRefinement::getRegionMaster
 Foam::meshRefinement::meshRefinement
 (
     fvMesh& mesh,
-    const scalar tol,
+    const scalar mergeDistance,
     const refinementSurfaces& surfaces,
     const shellSurfaces& shells
 )
 :
     mesh_(mesh),
-    tol_(tol),
+    mergeDistance_(mergeDistance),
     surfaces_(surfaces),
     shells_(shells),
     meshCutter_
@@ -718,6 +718,141 @@ Foam::labelList Foam::meshRefinement::decomposeCombineRegions
 }
 
 
+Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
+(
+    const bool keepZoneFaces,
+    const bool keepBaffles,
+    decompositionMethod& decomposer,
+    fvMeshDistribute& distributor
+)
+{
+    autoPtr<mapDistributePolyMesh> map;
+
+    if (Pstream::parRun())
+    {
+        //Info<< nl
+        //    << "Doing final balancing" << nl
+        //    << "---------------------" << nl
+        //    << endl;
+        //
+        //if (debug_)
+        //{
+        //    const_cast<Time&>(mesh_.time())++;
+        //}
+
+        // 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 = getDuplicateFaces   // all baffles
+                (
+                    identity(mesh_.nFaces()-mesh_.nInternalFaces())
+                   +mesh_.nInternalFaces()
+                );
+
+                Info<< "Found " << returnReduce(couples.size(), sumOp<label>())
+                    << " baffles to keep together."
+                    << endl;
+            }
+
+            distribution = 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
+        distribute(map);
+    }
+    return map;
+}
+
+
 // Helper function to get intersected faces
 Foam::labelList Foam::meshRefinement::intersectedFaces() const
 {
@@ -941,6 +1076,101 @@ Foam::tmp<Foam::pointVectorField> Foam::meshRefinement::makeDisplacementField
 }
 
 
+void Foam::meshRefinement::checkCoupledFaceZones(const polyMesh& mesh)
+{
+    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
+                    (
+                        "meshRefinement::checkCoupledFaceZones(const polyMesh&)"
+                    )   << "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
+                    (
+                        "meshRefinement::checkCoupledFaceZones(const polyMesh&)"
+                    )   << "Face " << fZone[i] << " in zone "
+                        << fZone.name()
+                        << " is twice in zone!"
+                        << abort(FatalError);
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "meshRefinement::checkCoupledFaceZones(const polyMesh&)"
+                    )   << "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
+            (
+                "meshRefinement::checkCoupledFaceZones(const polyMesh&)"
+            )   << "Face " << mesh.nInternalFaces()+i
+                << " is in zone " << faceToZone[i]
+                << ", its coupled face is in zone " << neiFaceToZone[i]
+                << abort(FatalError);
+        }
+    }
+}
+
+
 // Adds patch if not yet there. Returns patchID.
 Foam::label Foam::meshRefinement::addPatch
 (
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
index e8e633bfef..d27eaae413 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
@@ -94,7 +94,7 @@ public:
         {
             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 */
+            REMOVE = 4      /*!< set value to -1 any face that was refined */
         };
 
 
@@ -106,7 +106,7 @@ private:
         fvMesh& mesh_;
 
         //- tolerance used for sorting coordinates (used in 'less' routine)
-        const scalar tol_;
+        const scalar mergeDistance_;
 
         //- All surface-intersection interaction
         const refinementSurfaces& surfaces_;
@@ -383,7 +383,7 @@ public:
         meshRefinement
         (
             fvMesh& mesh,
-            const scalar tol,
+            const scalar mergeDistance,
             const refinementSurfaces&,
             const shellSurfaces&
         );
@@ -403,12 +403,23 @@ public:
                 return mesh_;
             }
 
+            scalar mergeDistance() const
+            {
+                return mergeDistance_;
+            }
+
             //- reference to surface search engines
             const refinementSurfaces& surfaces() const
             {
                 return surfaces_;
             }
 
+            //- reference to refinement shells (regions)
+            const shellSurfaces& shells() const
+            {
+                return shells_;
+            }
+
             //- reference to meshcutting engine
             const hexRef8& meshCutter() const
             {
@@ -458,6 +469,18 @@ public:
                 decompositionMethod&
             ) const;
 
+            //- 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,
+                decompositionMethod& decomposer,
+                fvMeshDistribute& distributor
+            );
+
             //- Get faces with intersection.
             labelList intersectedFaces() const;
 
@@ -486,6 +509,9 @@ public:
                 const labelList& adaptPatchIDs
             );
 
+            //- Helper function: check that face zones are synced
+            static void checkCoupledFaceZones(const polyMesh&);
+
 
         // Refinement
 
@@ -626,7 +652,7 @@ public:
             template<class T>
             void testSyncBoundaryFaceList
             (
-                const scalar tol,
+                const scalar mergeDistance,
                 const string&,
                 const UList<T>&,
                 const UList<T>&
diff --git a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
index b7cbc91696..edb613d966 100644
--- a/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
+++ b/src/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.H
@@ -26,8 +26,8 @@ Class
     Foam::refinementSurfaces
 
 Description
-    Container for triSurfaces used for surface-driven refinement.
-    These contain all the data about the level of refinement needed per
+    Container for data on surfaces used for surface-driven refinement.
+    Contains all the data about the level of refinement needed per
     surface.
 
 SourceFiles
@@ -126,6 +126,11 @@ public:
 
         // Access
 
+            const searchableSurfaces& geometry() const
+            {
+                return allGeometry_;
+            }
+
             const labelList& surfaces() const
             {
                 return surfaces_;
diff --git a/src/meshTools/searchableSurface/searchableBox.C b/src/meshTools/searchableSurface/searchableBox.C
index be3969d6f4..cb664b5757 100644
--- a/src/meshTools/searchableSurface/searchableBox.C
+++ b/src/meshTools/searchableSurface/searchableBox.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableBox.H b/src/meshTools/searchableSurface/searchableBox.H
index f606f83e1e..1c51311511 100644
--- a/src/meshTools/searchableSurface/searchableBox.H
+++ b/src/meshTools/searchableSurface/searchableBox.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSphere.C b/src/meshTools/searchableSurface/searchableSphere.C
index eb16e27318..039be46749 100644
--- a/src/meshTools/searchableSurface/searchableSphere.C
+++ b/src/meshTools/searchableSurface/searchableSphere.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSphere.H b/src/meshTools/searchableSurface/searchableSphere.H
index 7b3f4856ac..61b114de4e 100644
--- a/src/meshTools/searchableSurface/searchableSphere.H
+++ b/src/meshTools/searchableSurface/searchableSphere.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurface.C b/src/meshTools/searchableSurface/searchableSurface.C
index 9e6cffa315..4eba2d573b 100644
--- a/src/meshTools/searchableSurface/searchableSurface.C
+++ b/src/meshTools/searchableSurface/searchableSurface.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurface.H b/src/meshTools/searchableSurface/searchableSurface.H
index 43e008ca50..f9dc8b1289 100644
--- a/src/meshTools/searchableSurface/searchableSurface.H
+++ b/src/meshTools/searchableSurface/searchableSurface.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurfaces.C b/src/meshTools/searchableSurface/searchableSurfaces.C
index 8fbb4678e7..9689744fca 100644
--- a/src/meshTools/searchableSurface/searchableSurfaces.C
+++ b/src/meshTools/searchableSurface/searchableSurfaces.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurfaces.H b/src/meshTools/searchableSurface/searchableSurfaces.H
index acb02572e6..4e6c1bc2ed 100644
--- a/src/meshTools/searchableSurface/searchableSurfaces.H
+++ b/src/meshTools/searchableSurface/searchableSurfaces.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurfacesQueries.C b/src/meshTools/searchableSurface/searchableSurfacesQueries.C
index 7d7c6c2c1b..ed80762819 100644
--- a/src/meshTools/searchableSurface/searchableSurfacesQueries.C
+++ b/src/meshTools/searchableSurface/searchableSurfacesQueries.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/searchableSurfacesQueries.H b/src/meshTools/searchableSurface/searchableSurfacesQueries.H
index dcb84050a6..599d186bae 100644
--- a/src/meshTools/searchableSurface/searchableSurfacesQueries.H
+++ b/src/meshTools/searchableSurface/searchableSurfacesQueries.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.C b/src/meshTools/searchableSurface/triSurfaceMesh.C
index 526646c014..9751e3a3ef 100644
--- a/src/meshTools/searchableSurface/triSurfaceMesh.C
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
diff --git a/src/meshTools/searchableSurface/triSurfaceMesh.H b/src/meshTools/searchableSurface/triSurfaceMesh.H
index 1b9fa0c945..8a0709386c 100644
--- a/src/meshTools/searchableSurface/triSurfaceMesh.H
+++ b/src/meshTools/searchableSurface/triSurfaceMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 1991-2007 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License