From 27e7361627a5fc72bfb3509414783273b8a49ead Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Tue, 25 Feb 2014 17:02:28 +0000
Subject: [PATCH 1/4] GIT: damBreak4Phase: generated file

---
 .../damBreak4phase/constant/polyMesh/boundary | 53 -------------------
 1 file changed, 53 deletions(-)
 delete mode 100644 tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/constant/polyMesh/boundary

diff --git a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/constant/polyMesh/boundary b/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/constant/polyMesh/boundary
deleted file mode 100644
index 1b4dbb60aa..0000000000
--- a/tutorials/multiphase/multiphaseInterFoam/laminar/damBreak4phase/constant/polyMesh/boundary
+++ /dev/null
@@ -1,53 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      ascii;
-    class       polyBoundaryMesh;
-    location    "constant/polyMesh";
-    object      boundary;
-}
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-5
-(
-    leftWall
-    {
-        type            wall;
-        nFaces          50;
-        startFace       4432;
-    }
-    rightWall
-    {
-        type            wall;
-        nFaces          50;
-        startFace       4482;
-    }
-    lowerWall
-    {
-        type            wall;
-        nFaces          62;
-        startFace       4532;
-    }
-    atmosphere
-    {
-        type            patch;
-        nFaces          46;
-        startFace       4594;
-    }
-    defaultFaces
-    {
-        type            empty;
-        inGroups        1(empty);
-        nFaces          4536;
-        startFace       4640;
-    }
-)
-
-// ************************************************************************* //

From b7fbc77183b4341ee4f6ee6482e1cd7889bb2b37 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 26 Feb 2014 14:42:50 +0000
Subject: [PATCH 2/4] ENH: snappyHexMesh: multiple locationsInMesh, layers on
 faceZones

---
 .../generation/snappyHexMesh/snappyHexMesh.C  |  146 +-
 .../snappyHexMesh/snappyHexMeshDict           |  119 +-
 .../autoHexMeshDriver/autoLayerDriver.C       | 1480 ++++++----
 .../autoHexMeshDriver/autoLayerDriver.H       |   21 +-
 .../autoHexMeshDriver/autoRefineDriver.C      |  166 +-
 .../autoHexMeshDriver/autoRefineDriver.H      |   23 +-
 .../autoHexMeshDriver/autoSnapDriver.C        |  773 ++----
 .../autoHexMeshDriver/autoSnapDriver.H        |  141 +-
 .../autoHexMeshDriver/autoSnapDriverFeature.C |  903 ++++--
 .../layerParameters/layerParameters.C         |    8 +
 .../layerParameters/layerParameters.H         |    7 +
 .../refinementParameters.C                    |  161 +-
 .../refinementParameters.H                    |   61 +-
 .../refinementParameters/wordPairHashTable.H  |   56 +
 .../snapParameters/snapParameters.C           |   14 +-
 .../snapParameters/snapParameters.H           |  108 +-
 .../medialAxisMeshMover.C                     |   47 +-
 .../meshRefinement/meshRefinement.C           | 1272 ++++-----
 .../meshRefinement/meshRefinement.H           |  191 +-
 .../meshRefinement/meshRefinementBaffles.C    | 2431 +++++++++++------
 .../meshRefinement/meshRefinementMerge.C      |  215 +-
 .../refinementSurfaces/surfaceZonesInfo.C     |  121 +-
 .../refinementSurfaces/surfaceZonesInfo.H     |   18 +-
 23 files changed, 5641 insertions(+), 2841 deletions(-)
 create mode 100644 src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/wordPairHashTable.H

diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
index d7eeb9185b..d085c34f3b 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C
@@ -1121,6 +1121,38 @@ int main(int argc, char *argv[])
     );
 
 
+    // Refinement parameters
+    const refinementParameters refineParams(refineDict);
+
+    // Snap parameters
+    const snapParameters snapParams(snapDict);
+
+
+
+    // Add all the cellZones and faceZones
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // 1. cellZones relating to surface (faceZones added later)
+
+    const labelList namedSurfaces
+    (
+        surfaceZonesInfo::getNamedSurfaces(surfaces.surfZones())
+    );
+
+    labelList surfaceToCellZone = surfaceZonesInfo::addCellZonesToMesh
+    (
+        surfaces.surfZones(),
+        namedSurfaces,
+        mesh
+    );
+
+
+    // 2. cellZones relating to locations
+
+    refineParams.addCellZonesToMesh(mesh);
+
+
+
     // Add all the surface regions as patches
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1128,6 +1160,8 @@ int main(int argc, char *argv[])
     //  (faceZone surfaces)
     labelList globalToMasterPatch;
     labelList globalToSlavePatch;
+
+
     {
         Info<< nl
             << "Adding patches for surface regions" << nl
@@ -1148,6 +1182,7 @@ int main(int argc, char *argv[])
 
         const labelList& surfaceGeometry = surfaces.surfaces();
         const PtrList<dictionary>& surfacePatchInfo = surfaces.patchInfo();
+        const polyBoundaryMesh& pbm = mesh.boundaryMesh();
 
         forAll(surfaceGeometry, surfI)
         {
@@ -1157,7 +1192,9 @@ int main(int argc, char *argv[])
 
             Info<< surfaces.names()[surfI] << ':' << nl << nl;
 
-            if (surfaces.surfZones()[surfI].faceZoneName().empty())
+            const word& fzName = surfaces.surfZones()[surfI].faceZoneName();
+
+            if (fzName.empty())
             {
                 // 'Normal' surface
                 forAll(regNames, i)
@@ -1188,7 +1225,7 @@ int main(int argc, char *argv[])
 
                     Info<< setf(ios_base::left)
                         << setw(6) << patchI
-                        << setw(20) << mesh.boundaryMesh()[patchI].type()
+                        << setw(20) << pbm[patchI].type()
                         << setw(30) << regNames[i] << nl;
 
                     globalToMasterPatch[globalRegionI] = patchI;
@@ -1228,7 +1265,7 @@ int main(int argc, char *argv[])
 
                         Info<< setf(ios_base::left)
                             << setw(6) << patchI
-                            << setw(20) << mesh.boundaryMesh()[patchI].type()
+                            << setw(20) << pbm[patchI].type()
                             << setw(30) << regNames[i] << nl;
 
                         globalToMasterPatch[globalRegionI] = patchI;
@@ -1260,12 +1297,27 @@ int main(int argc, char *argv[])
 
                         Info<< setf(ios_base::left)
                             << setw(6) << patchI
-                            << setw(20) << mesh.boundaryMesh()[patchI].type()
+                            << setw(20) << pbm[patchI].type()
                             << setw(30) << slaveName << nl;
 
                         globalToSlavePatch[globalRegionI] = patchI;
                     }
                 }
+
+                // For now: have single faceZone per surface. Use first
+                // region in surface for patch for zoneing
+                if (regNames.size())
+                {
+                    label globalRegionI = surfaces.globalRegion(surfI, 0);
+
+                    meshRefiner.addFaceZone
+                    (
+                        fzName,
+                        pbm[globalToMasterPatch[globalRegionI]].name(),
+                        pbm[globalToSlavePatch[globalRegionI]].name(),
+                        surfaces.surfZones()[surfI].faceType()
+                    );
+                }
             }
 
             Info<< nl;
@@ -1275,6 +1327,73 @@ int main(int argc, char *argv[])
     }
 
 
+
+    // Add all information for all the remaining faceZones
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    wordPairHashTable zonesToFaceZone;
+    forAll(mesh.faceZones(), zoneI)
+    {
+        const word& fzName = mesh.faceZones()[zoneI].name();
+
+        label mpI, spI;
+        surfaceZonesInfo::faceZoneType fzType;
+        bool hasInfo = meshRefiner.getFaceZoneInfo(fzName, mpI, spI, fzType);
+
+        if (!hasInfo)
+        {
+            // faceZone does not originate from a surface but presumably
+            // from a cellZone pair instead
+            string::size_type i = fzName.find("_to_");
+            if (i != string::npos)
+            {
+                word cz0 = fzName.substr(0, i);
+                word cz1 = fzName.substr(i+4, fzName.size()-i+4);
+                zonesToFaceZone.insert(Pair<word>(cz0, cz1), fzName);
+            }
+        }
+    }
+
+    if (zonesToFaceZone.size())
+    {
+        autoRefineDriver::addFaceZones
+        (
+            meshRefiner,
+            refineParams,
+            zonesToFaceZone
+        );
+    }
+
+
+
+    // Re-do intersections on meshed boundaries since they use an extrapolated
+    // other side
+    {
+        const labelList adaptPatchIDs(meshRefiner.meshedPatches());
+
+        const polyBoundaryMesh& pbm = mesh.boundaryMesh();
+
+        label nFaces = 0;
+        forAll(adaptPatchIDs, i)
+        {
+            nFaces += pbm[adaptPatchIDs[i]].size();
+        }
+
+        labelList faceLabels(nFaces);
+        nFaces = 0;
+        forAll(adaptPatchIDs, i)
+        {
+            const polyPatch& pp = pbm[adaptPatchIDs[i]];
+            forAll(pp, i)
+            {
+                faceLabels[nFaces++] = pp.start()+i;
+            }
+        }
+        meshRefiner.updateIntersections(faceLabels);
+    }
+
+
+
     // Parallel
     // ~~~~~~~~
 
@@ -1312,14 +1431,13 @@ int main(int argc, char *argv[])
     const Switch wantSnap(meshDict.lookup("snap"));
     const Switch wantLayers(meshDict.lookup("addLayers"));
 
-    // Refinement parameters
-    const refinementParameters refineParams(refineDict);
+    const Switch keepHex(meshDict.lookupOrDefault("keepHex", false));
 
-    // Snap parameters
-    const snapParameters snapParams(snapDict);
-
-    // Layer addition parameters
-    const layerParameters layerParams(layerDict, mesh.boundaryMesh());
+    if (keepHex)
+    {
+        Info<< "Avoiding generating non-(split)hex cells." << nl
+            << endl;
+    }
 
 
     if (wantRefine)
@@ -1348,6 +1466,7 @@ int main(int argc, char *argv[])
             refineParams,
             snapParams,
             refineParams.handleSnapProblems(),
+            keepHex,        // keepHex
             motionDict
         );
 
@@ -1387,6 +1506,7 @@ int main(int argc, char *argv[])
         (
             snapDict,
             motionDict,
+            !keepHex,       // mergePatchFaces
             curvature,
             planarAngle,
             snapParams
@@ -1408,6 +1528,9 @@ int main(int argc, char *argv[])
     {
         cpuTime timer;
 
+        // Layer addition parameters
+        const layerParameters layerParams(layerDict, mesh.boundaryMesh());
+
         autoLayerDriver layerDriver
         (
             meshRefiner,
@@ -1433,6 +1556,7 @@ int main(int argc, char *argv[])
             layerDict,
             motionDict,
             layerParams,
+            !keepHex,       //mergePatchFaces
             preBalance,
             decomposer,
             distributor
diff --git a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
index 49958bb34f..39e975a6dd 100644
--- a/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
+++ b/applications/utilities/mesh/generation/snappyHexMesh/snappyHexMeshDict
@@ -71,6 +71,12 @@ geometry
     }
 };
 
+
+// Optional: avoid patch-face merging. Allows mesh to be used for
+//           refinement/unrefinement
+//keepHex true;
+
+
 // Settings for the castellatedMesh generation.
 castellatedMeshControls
 {
@@ -177,7 +183,7 @@ castellatedMeshControls
             //  how to select the cells that are in the cellZone
             //  (inside / outside / specified insidePoint)
             //  The orientation of the faceZone is
-            //  - if on cellZone(s) : point out of (maximum) cellZone
+            //  - if on cellZone(s) : point out of (minimum) cellZone
             //  - if freestanding   : oriented according to surface
 
             //faceZone sphere;
@@ -249,17 +255,70 @@ castellatedMeshControls
 
     // 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.
+    // section reachable from the location(s)InMesh is kept.
     // NOTE: This point should never be on a face, always inside a cell, even
     // after refinement.
-    locationInMesh (5 0.28 0.43);
+    //
+    // There are two different ways of specifying the regions to keep:
+    // 1. a single locationInMesh. All the 'zoned' surfaces are marked as such
+    //    in the refinementSurfaces with the faceZone and cellZone keywords.
+    //
+    // or
+    //
+    // 2. multiple locationsInMesh, with per location the name of the cellZone.
+    //    This uses walking to determine zones and automatically creates
+    //    faceZones on the outside of cellZones.
 
-    // Whether any faceZones (as specified in the refinementSurfaces)
-    // are only on the boundary of corresponding cellZones or also allow
-    // free-standing zone faces and zone faces on boundaries. Not used if
-    // there are no faceZones.
-    allowFreeStandingZoneFaces true;
 
+        // Ad 1. Specify a single location and how to treat faces inbetween
+        //       cellZones
+        locationInMesh (5 0.28 0.43);
+
+        // Whether any faceZones (as specified in the refinementSurfaces)
+        // are only on the boundary of corresponding cellZones or also allow
+        // free-standing zone faces. Not used if there are no faceZones.
+        allowFreeStandingZoneFaces true;
+
+
+
+        // 2. Specify multiple locations with optional cellZones for the
+        //    regions. faceZones are automatically constructed from the
+        //    names of the cellZones: <cellZoneA> _to_ <cellZoneB>
+        //    where the cellZoneA is the lowest numbered cellZone (non-cellZone
+        //    cells are in a special region called "none" which is always
+        //    last).
+
+        locationsInMesh
+        (
+            ((-0.09 -0.039 -0.049)  bottomAir)  // cellZone 0
+            ((-0.09 0.009 -0.049)   topAir)     // cellZone 1
+            ((-0.09 0.001 -0.049)   leftSolid)  // cellZone 2
+            ((0.02  0.001 -0.049)   rightSolid) // cellZone 3
+            ((-0.001 -0.039 0.0015) heater)     // cellZone 4
+        );
+
+        // Per synthesised faceZone name the faceType and type of baffles to
+        // create
+        faceZoneControls
+        {
+            bottomAir_to_heater
+            {
+                // Optional specification of patch type (default is wall). No
+                // constraint types (cyclic, symmetry) etc. are allowed.
+                patchInfo
+                {
+                    type patch;
+                    inGroups (patchPatches);
+                }
+                faceType baffle;
+            }
+        }
+
+
+
+    // Optional locations that should not be reachable from
+    // location(s)InMesh
+    locationsOutsideMesh ((100 100 100));
 
     // Optional: do not remove cells likely to give snapping problems
     // handleSnapProblems false;
@@ -288,6 +347,11 @@ snapControls
     // before upon reaching a correct mesh.
     nRelaxIter 5;
 
+    // (wip) disable snapping to opposite near surfaces (revert to 22x
+    //  behaviour)
+    // detectNearSurfacesSnap false;
+
+
     // Feature snapping
 
         // Number of feature edge snapping iterations.
@@ -306,8 +370,28 @@ snapControls
         multiRegionFeatureSnap false;
 
 
-    // wip: disable snapping to opposite near surfaces (revert to 22x behaviour)
-    // detectNearSurfacesSnap false;
+        //- When to run face splitting (never at first iteration, always
+        //  at last iteration). Is interval. Default -1 (disabled)
+        //nFaceSplitInterval 5;
+
+
+        // (wip) Optional for explicit feature snapping:
+        //- Detect baffle edges. Default is true.
+        //detectBaffles false;
+        //- Erase attraction close to feature point. Default is false.
+        //releasePoints true;
+        //- Walk along feature edges, adding missing ones. Default is true.
+        //stringFeatures false;
+        //- If diagonal attraction also attract other face points. Default is
+        //  false
+        //avoidDiagonal true;
+        //- When splitting what concave faces to leave intact. Default is 45
+        //  degrees.
+        //concaveAngle 30;
+        //- When splitting the minimum area ratio of faces. If face split
+        //  causes ratio of area less than this do not split. Default is 0.3
+        //minAreaRatio 0.3;
+
 }
 
 // Settings for the layer addition.
@@ -348,7 +432,7 @@ addLayersControls
     // cannot be above minThickness do not add layer.
     // If relativeSizes this is relative to undistorted size of cell
     // outside layer..
-    minThickness 0.25;
+    minThickness 0.1;
 
 
     // Per final patch (so not geometry!) the layer information
@@ -395,6 +479,13 @@ addLayersControls
         // are perpendicular
         featureAngle 130;
 
+        // When to merge patch faces. Default is 0.5*featureAngle
+        //mergePatchFacesAngle 45;
+
+        // Do not extrude around sharp edge if not both faces are extruded.
+        // Default is 0.5*featureAngle. Set to -180 always attempt extrusion
+        layerTerminationAngle -180;
+
         // Stop layer growth on highly warped cells
         maxFaceThicknessRatio 0.5;
 
@@ -431,8 +522,10 @@ addLayersControls
         // default is 0.
         //nSmoothDisplacement 90;
 
-        // (wip)Optional: do not extrude a point if none of the surrounding points is
-        // not extruded. Default is false.
+        // (wip)Optional: do not extrude any point where
+        //   (false) : all surrounding faces are not fully extruded
+        //   (true)  : all surrounding points are not extruded
+        // Default is false.
         //detectExtrusionIsland true;
 
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
index 08c8f7e530..b8bf5af1d8 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
@@ -2418,6 +2418,67 @@ Foam::label Foam::autoLayerDriver::countExtrusion
 }
 
 
+Foam::List<Foam::labelPair> Foam::autoLayerDriver::getBafflesOnAddedMesh
+(
+    const polyMesh& mesh,
+    const labelList& newToOldFaces,
+    const List<labelPair>& baffles
+)
+{
+    // The problem is that the baffle faces are now inside the
+    // mesh (addPatchCellLayer modifies original boundary faces and
+    // adds new ones. So 2 pass:
+    // - find the boundary face for all faces originating from baffle
+    // - use the boundary face for the new baffles
+
+    Map<label> baffleSet(4*baffles.size());
+    forAll(baffles, baffleI)
+    {
+        baffleSet.insert(baffles[baffleI][0], baffleI);
+        baffleSet.insert(baffles[baffleI][1], baffleI);
+    }
+
+
+    List<labelPair> newBaffles(baffles.size(), labelPair(-1, -1));
+    for
+    (
+        label faceI = mesh.nInternalFaces();
+        faceI < mesh.nFaces();
+        faceI++
+    )
+    {
+        label oldFaceI = newToOldFaces[faceI];
+
+        Map<label>::const_iterator faceFnd = baffleSet.find(oldFaceI);
+        if (faceFnd != baffleSet.end())
+        {
+            label baffleI = faceFnd();
+            labelPair& p = newBaffles[baffleI];
+            if (p[0] == -1)
+            {
+                p[0] = faceI;
+            }
+            else if (p[1] == -1)
+            {
+                p[1] = faceI;
+            }
+            else
+            {
+                FatalErrorIn("addLayers(..)")
+                    << "Problem:" << faceI << " at:"
+                    << mesh.faceCentres()[faceI]
+                    << " is on same baffle as " << p[0]
+                    << " at:" << mesh.faceCentres()[p[0]]
+                    << " and " << p[1]
+                    << " at:" << mesh.faceCentres()[p[1]]
+                    << exit(FatalError);
+            }
+        }
+    }
+    return newBaffles;
+}
+
+
 // Collect layer faces and layer cells into mesh fields for ease of handling
 void Foam::autoLayerDriver::getLayerCellsFaces
 (
@@ -2448,6 +2509,7 @@ void Foam::autoLayerDriver::getLayerCellsFaces
 
         if (layer.size())
         {
+            // Leave out original internal face
             forAll(added, i)
             {
                 cellNLayers[added[i]] = layer.size()-1;
@@ -2568,6 +2630,69 @@ void Foam::autoLayerDriver::printLayerData
 }
 
 
+bool Foam::autoLayerDriver::writeLayerSets
+(
+    const fvMesh& mesh,
+    const labelList& cellNLayers,
+    const scalarField& faceRealThickness
+) const
+{
+    bool allOk = true;
+    {
+        label nAdded = 0;
+        forAll(cellNLayers, cellI)
+        {
+            if (cellNLayers[cellI] > 0)
+            {
+                nAdded++;
+            }
+        }
+        cellSet addedCellSet(mesh, "addedCells", nAdded);
+        forAll(cellNLayers, cellI)
+        {
+            if (cellNLayers[cellI] > 0)
+            {
+                addedCellSet.insert(cellI);
+            }
+        }
+        addedCellSet.instance() = meshRefiner_.timeName();
+        Info<< "Writing "
+            << returnReduce(addedCellSet.size(), sumOp<label>())
+            << " added cells to cellSet "
+            << addedCellSet.name() << endl;
+        bool ok = addedCellSet.write();
+        allOk = allOk && ok;
+    }
+    {
+        label nAdded = 0;
+        for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+        {
+            if (faceRealThickness[faceI] > 0)
+            {
+                nAdded++;
+            }
+        }
+
+        faceSet layerFacesSet(mesh, "layerFaces", nAdded);
+        for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
+        {
+            if (faceRealThickness[faceI] > 0)
+            {
+                layerFacesSet.insert(faceI);
+            }
+        }
+        layerFacesSet.instance() = meshRefiner_.timeName();
+        Info<< "Writing "
+            << returnReduce(layerFacesSet.size(), sumOp<label>())
+            << " faces inside added layer to faceSet "
+            << layerFacesSet.name() << endl;
+        bool ok = layerFacesSet.write();
+        allOk = allOk && ok;
+    }
+    return allOk;
+}
+
+
 bool Foam::autoLayerDriver::writeLayerData
 (
     const fvMesh& mesh,
@@ -2581,57 +2706,8 @@ bool Foam::autoLayerDriver::writeLayerData
 
     if (meshRefinement::writeLevel() & meshRefinement::WRITELAYERSETS)
     {
-        {
-            label nAdded = 0;
-            forAll(cellNLayers, cellI)
-            {
-                if (cellNLayers[cellI] > 0)
-                {
-                    nAdded++;
-                }
-            }
-            cellSet addedCellSet(mesh, "addedCells", nAdded);
-            forAll(cellNLayers, cellI)
-            {
-                if (cellNLayers[cellI] > 0)
-                {
-                    addedCellSet.insert(cellI);
-                }
-            }
-            addedCellSet.instance() = meshRefiner_.timeName();
-            Info<< "Writing "
-                << returnReduce(addedCellSet.size(), sumOp<label>())
-                << " added cells to cellSet "
-                << addedCellSet.name() << endl;
-            bool ok = addedCellSet.write();
-            allOk = allOk & ok;
-        }
-        {
-            label nAdded = 0;
-            for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
-            {
-                if (faceRealThickness[faceI] > 0)
-                {
-                    nAdded++;
-                }
-            }
-
-            faceSet layerFacesSet(mesh, "layerFaces", nAdded);
-            for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
-            {
-                if (faceRealThickness[faceI] > 0)
-                {
-                    layerFacesSet.insert(faceI);
-                }
-            }
-            layerFacesSet.instance() = meshRefiner_.timeName();
-            Info<< "Writing "
-                << returnReduce(layerFacesSet.size(), sumOp<label>())
-                << " faces inside added layer to faceSet "
-                << layerFacesSet.name() << endl;
-            bool ok = layerFacesSet.write();
-            allOk = allOk & ok;
-        }
+        bool ok = writeLayerSets(mesh, cellNLayers, faceRealThickness);
+        allOk = allOk && ok;
     }
 
     if (meshRefinement::writeLevel() & meshRefinement::WRITELAYERFIELDS)
@@ -2654,6 +2730,10 @@ bool Foam::autoLayerDriver::writeLayerData
                 dimensionedScalar("zero", dimless, 0),
                 fixedValueFvPatchScalarField::typeName
             );
+            forAll(fld, cellI)
+            {
+                fld[cellI] = cellNLayers[cellI];
+            }
             const polyBoundaryMesh& pbm = mesh.boundaryMesh();
             forAll(patchIDs, i)
             {
@@ -2670,7 +2750,7 @@ bool Foam::autoLayerDriver::writeLayerData
             Info<< indent << fld.name() << "    : actual number of layers"
                 << endl;
             bool ok = fld.write();
-            allOk = allOk & ok;
+            allOk = allOk && ok;
         }
         {
             volScalarField fld
@@ -2700,7 +2780,7 @@ bool Foam::autoLayerDriver::writeLayerData
             Info<< indent << fld.name() << "         : overall layer thickness"
                 << endl;
             bool ok = fld.write();
-            allOk = allOk & ok;
+            allOk = allOk && ok;
         }
         {
             volScalarField fld
@@ -2748,23 +2828,11 @@ bool Foam::autoLayerDriver::writeLayerData
                 << " : overall layer thickness (fraction"
                 << " of desired thickness)" << endl;
             bool ok = fld.write();
-            allOk = allOk & ok;
+            allOk = allOk && ok;
         }
         Info<< decrIndent<< endl;
     }
 
-    //if (meshRefinement::outputLevel() & meshRefinement::OUTPUTLAYERINFO)
-    {
-        printLayerData
-        (
-            mesh,
-            patchIDs,
-            cellNLayers,
-            faceWantedThickness,
-            faceRealThickness
-        );
-    }
-
     return allOk;
 }
 
@@ -2794,7 +2862,7 @@ void Foam::autoLayerDriver::mergePatchFacesUndo
 {
     // Clip to 30 degrees. Not helpful!
     //scalar planarAngle = min(30.0, layerParams.featureAngle());
-    scalar planarAngle = layerParams.featureAngle();
+    scalar planarAngle = layerParams.mergePatchFacesAngle();
     scalar minCos = Foam::cos(degToRad(planarAngle));
 
     scalar concaveCos = Foam::cos(degToRad(layerParams.concaveAngle()));
@@ -2805,8 +2873,7 @@ void Foam::autoLayerDriver::mergePatchFacesUndo
         << "    - which are on the same patch" << nl
         << "    - which make an angle < " << planarAngle
         << " degrees"
-        << nl
-        << "      (cos:" << minCos << ')' << nl
+        << " (cos:" << minCos << ')' << nl
         << "    - as long as the resulting face doesn't become concave"
         << " by more than "
         << layerParams.concaveAngle() << " degrees" << nl
@@ -2850,34 +2917,254 @@ void Foam::autoLayerDriver::addLayers
 {
     fvMesh& mesh = meshRefiner_.mesh();
 
-    // Create baffles (pairs of faces that share the same points)
-    // Baffles stored as owner and neighbour face that have been created.
-    List<labelPair> baffles;
-    meshRefiner_.createZoneBaffles
+
+    // faceZones of type internal or baffle (for merging points across)
+    labelList internalOrBaffleFaceZones;
+    {
+        List<surfaceZonesInfo::faceZoneType> fzTypes(2);
+        fzTypes[0] = surfaceZonesInfo::INTERNAL;
+        fzTypes[1] = surfaceZonesInfo::BAFFLE;
+        internalOrBaffleFaceZones = meshRefiner_.getZones(fzTypes);
+    }
+
+    // faceZones of type internal (for checking mesh quality across and
+    // merging baffles)
+    const labelList internalFaceZones
     (
-        globalToMasterPatch_,
-        globalToSlavePatch_,
-        baffles
+        meshRefiner_.getZones
+        (
+            List<surfaceZonesInfo::faceZoneType>
+            (
+                1,
+                surfaceZonesInfo::INTERNAL
+            )
+        )
     );
 
-    if (debug&meshRefinement::MESH)
+    // Create baffles (pairs of faces that share the same points)
+    // Baffles stored as owner and neighbour face that have been created.
     {
-        const_cast<Time&>(mesh.time())++;
-        Info<< "Writing baffled mesh to time "
-            << meshRefiner_.timeName() << endl;
-        meshRefiner_.write
+        List<labelPair> baffles;
+        labelList originatingFaceZone;
+        meshRefiner_.createZoneBaffles
         (
-            meshRefinement::debugType(debug),
-            meshRefinement::writeType
-            (
-                meshRefinement::writeLevel()
-              | meshRefinement::WRITEMESH
-            ),
-            mesh.time().path()/meshRefiner_.timeName()
+            identity(mesh.faceZones().size()),
+            baffles,
+            originatingFaceZone
         );
+
+
+        if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
+        {
+            const_cast<Time&>(mesh.time())++;
+            Info<< "Writing baffled mesh to time "
+                << meshRefiner_.timeName() << endl;
+            meshRefiner_.write
+            (
+                meshRefinement::debugType(debug),
+                meshRefinement::writeType
+                (
+                    meshRefinement::writeLevel()
+                  | meshRefinement::WRITEMESH
+                ),
+                mesh.time().path()/meshRefiner_.timeName()
+            );
+        }
     }
 
 
+    // Duplicate points on faceZones of type boundary. Should normally already
+    // be done by snapping phase
+    meshRefiner_.dupNonManifoldBoundaryPoints();
+
+
+
+    // Duplicate points on faceZones that layers are added to
+    labelList pointToDuplicate;
+    {
+        // Check outside of baffles for non-manifoldness
+        PackedBoolList duplicatePoint(mesh.nPoints());
+        {
+            // Do full analysis to see if we need to extrude points
+            // so have to duplicate them
+            autoPtr<indirectPrimitivePatch> pp
+            (
+                meshRefinement::makePatch
+                (
+                    mesh,
+                    patchIDs
+                )
+            );
+
+            // Displacement for all pp.localPoints.
+            vectorField patchDisp(pp().nPoints(), vector::one);
+            labelList patchNLayers(pp().nPoints(), 0);
+            label nIdealTotAddedCells = 0;
+            List<extrudeMode> extrudeStatus(pp().nPoints(), EXTRUDE);
+            // Get number of layers per point from number of layers per patch
+            setNumLayers
+            (
+                layerParams.numLayers(),// per patch the num layers
+                patchIDs,               // patches that are being moved
+                pp,                     // indirectpatch for all faces moving
+
+                patchDisp,
+                patchNLayers,
+                extrudeStatus,
+                nIdealTotAddedCells
+            );
+            // Make sure displacement is equal on both sides of coupled patches.
+            syncPatchDisplacement
+            (
+                pp,
+                scalarField(patchDisp.size(), 0.0), //minThickness,
+                patchDisp,
+                patchNLayers,
+                extrudeStatus
+            );
+
+            forAll(extrudeStatus, patchPointI)
+            {
+                if (extrudeStatus[patchPointI] != NOEXTRUDE)
+                {
+                    duplicatePoint[pp().meshPoints()[patchPointI]] = 1;
+                }
+            }
+
+            // Take all the faceZones without extrusion and disable
+            // duplication. This should not be necessary but mesh shrinking
+            // moves points so they cannot be merged afterwards
+            labelHashSet layerIDs(patchIDs);
+            forAll(mesh.faceZones(), zoneI)
+            {
+                const faceZone& fZone = mesh.faceZones()[zoneI];
+
+                label mpI, spI;
+                surfaceZonesInfo::faceZoneType fzType;
+                bool hasInfo = meshRefiner_.getFaceZoneInfo
+                (
+                    mesh.faceZones()[zoneI].name(),
+                    mpI,
+                    spI,
+                    fzType
+                );
+                if (hasInfo && !layerIDs.found(mpI) && !layerIDs.found(spI))
+                {
+                    forAll(fZone, i)
+                    {
+                        const face& f = mesh.faces()[fZone[i]];
+                        forAll(f, fp)
+                        {
+                            duplicatePoint[f[fp]] = 0;
+                        }
+                    }
+                }
+            }
+        }
+
+
+        // Duplicate points only if all points agree
+        syncTools::syncPointList
+        (
+            mesh,
+            duplicatePoint,
+            andEqOp<unsigned int>(),    // combine op
+            0u                          // null value
+        );
+        label n = duplicatePoint.count();
+        labelList candidatePoints(n);
+        n = 0;
+        forAll(duplicatePoint, pointI)
+        {
+            if (duplicatePoint[pointI])
+            {
+                candidatePoints[n++] = pointI;
+            }
+        }
+        localPointRegion regionSide(mesh, candidatePoints);
+        autoPtr<mapPolyMesh> map = meshRefiner_.dupNonManifoldPoints
+        (
+            regionSide
+        );
+
+        if (map.valid())
+        {
+            // Store point duplication
+            pointToDuplicate.setSize(mesh.nPoints(), -1);
+
+            const labelList& pointMap = map().pointMap();
+            const labelList& reversePointMap = map().reversePointMap();
+
+            forAll(pointMap, pointI)
+            {
+                label oldPointI = pointMap[pointI];
+                label newMasterPointI = reversePointMap[oldPointI];
+
+                if (newMasterPointI != pointI)
+                {
+                    // Found slave. Mark both master and slave
+                    pointToDuplicate[pointI] = newMasterPointI;
+                    pointToDuplicate[newMasterPointI] = newMasterPointI;
+                    //str.write
+                    //(
+                    //    linePointRef
+                    //    (
+                    //        mesh.points()[pointI],
+                    //        mesh.points()[newMasterPointI]
+                    //    )
+                    //);
+                }
+            }
+
+            if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
+            {
+                const_cast<Time&>(mesh.time())++;
+                Info<< "Writing point-duplicate mesh to time "
+                    << meshRefiner_.timeName() << endl;
+                meshRefiner_.write
+                (
+                    meshRefinement::debugType(debug),
+                    meshRefinement::writeType
+                    (
+                        meshRefinement::writeLevel()
+                      | meshRefinement::WRITEMESH
+                    ),
+                    mesh.time().path()/meshRefiner_.timeName()
+                );
+
+                OBJstream str
+                (
+                    mesh.time().path()
+                  / "duplicatePoints_"
+                  + meshRefiner_.timeName()
+                  + ".obj"
+                );
+                Info<< "Writing point-duplicates to " << str.name() << endl;
+                const pointField& p = mesh.points();
+                forAll(pointMap, pointI)
+                {
+                    label newMasterI = reversePointMap[pointMap[pointI]];
+
+                    if (newMasterI != pointI)
+                    {
+                        str.write(linePointRef(p[pointI], p[newMasterI]));
+                    }
+                }
+            }
+        }
+    }
+
+
+    // Add layers to patches
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    // Now we have
+    // - mesh with optional baffles and duplicated points for faceZones
+    //   where layers are to be added
+    // - pointToDuplicate : correspondence for duplicated points
+    // - baffles          : list of pairs of faces
+
+
     autoPtr<indirectPrimitivePatch> pp
     (
         meshRefinement::makePatch
@@ -2936,8 +3223,8 @@ void Foam::autoLayerDriver::addLayers
 
 
     {
-        // Get number of layer per point from number of layers per patch
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        // Get number of layers per point from number of layers per patch
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
         setNumLayers
         (
@@ -3068,41 +3355,6 @@ void Foam::autoLayerDriver::addLayers
 
 
 
-    // Overall displacement field
-    pointVectorField displacement
-    (
-        makeLayerDisplacementField
-        (
-            pointMesh::New(mesh),
-            layerParams.numLayers()
-        )
-    );
-
-    // Allocate run-time selectable mesh mover
-    autoPtr<externalDisplacementMeshMover> medialAxisMoverPtr;
-    {
-        // Set up controls for meshMover
-        dictionary combinedDict(layerParams.dict());
-        // Add mesh quality constraints
-        combinedDict.merge(motionDict);
-        // Where to get minThickness from
-        combinedDict.add("minThicknessName", minThickness.name());
-
-        // Take over patchDisp as boundary conditions on displacement
-        // pointVectorField
-        medialAxisMoverPtr = externalDisplacementMeshMover::New
-        (
-            layerParams.meshShrinker(),
-            combinedDict,
-            baffles,
-            displacement
-        );
-    }
-
-
-    // Saved old points
-    pointField oldPoints(mesh.points());
-
     // Current set of topology changes. (changing mesh clears out
     // polyTopoChange)
     polyTopoChange savedMeshMod(mesh.boundaryMesh().size());
@@ -3118,127 +3370,450 @@ void Foam::autoLayerDriver::addLayers
     }
 
 
-    for (label iteration = 0; iteration < layerParams.nLayerIter(); iteration++)
     {
-        Info<< nl
-            << "Layer addition iteration " << iteration << nl
-            << "--------------------------" << endl;
-
-
-        // Unset the extrusion at the pp.
-        const dictionary& meshQualityDict =
+        // Overall displacement field
+        pointVectorField displacement
         (
-            iteration < layerParams.nRelaxedIter()
-          ? motionDict
-          : motionDict.subDict("relaxed")
-        );
-
-        if (iteration >= layerParams.nRelaxedIter())
-        {
-            Info<< "Switched to relaxed meshQuality constraints." << endl;
-        }
-
-
-
-        // Make sure displacement is equal on both sides of coupled patches.
-        syncPatchDisplacement
-        (
-            pp,
-            minThickness,
-            patchDisp,
-            patchNLayers,
-            extrudeStatus
-        );
-
-        // Displacement acc. to pointnormals
-        getPatchDisplacement
-        (
-            pp,
-            thickness,
-            minThickness,
-            patchDisp,
-            patchNLayers,
-            extrudeStatus
-        );
-
-        // Shrink mesh by displacement value first.
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-        {
-            pointField oldPatchPos(pp().localPoints());
-
-            // Take over patchDisp into pointDisplacement field and
-            // adjust both for multi-patch constraints
-            motionSmootherAlgo::setDisplacement
+            makeLayerDisplacementField
             (
-                patchIDs,
-                pp,
-                patchDisp,
-                displacement
-            );
-
-
-            // Move mesh
-            // ~~~~~~~~~
+                pointMesh::New(mesh),
+                layerParams.numLayers()
+            )
+        );
 
+        // Allocate run-time selectable mesh mover
+        autoPtr<externalDisplacementMeshMover> medialAxisMoverPtr;
+        {
             // Set up controls for meshMover
             dictionary combinedDict(layerParams.dict());
-            // Add standard quality constraints
+            // Add mesh quality constraints
             combinedDict.merge(motionDict);
-            // Add relaxed constraints (overrides standard ones)
-            combinedDict.merge(meshQualityDict);
             // Where to get minThickness from
             combinedDict.add("minThicknessName", minThickness.name());
 
-            labelList checkFaces(identity(mesh.nFaces()));
-            medialAxisMoverPtr().move
+            const List<labelPair> internalBaffles
             (
-                combinedDict,
-                nAllowableErrors,
-                checkFaces
+                meshRefinement::subsetBaffles
+                (
+                    mesh,
+                    internalFaceZones,
+                    localPointRegion::findDuplicateFacePairs(mesh)
+                )
             );
 
-            pp().movePoints(mesh.points());
-
-            // Update patchDisp (since not all might have been honoured)
-            patchDisp = oldPatchPos - pp().localPoints();
+            // Take over patchDisp as boundary conditions on displacement
+            // pointVectorField
+            medialAxisMoverPtr = externalDisplacementMeshMover::New
+            (
+                layerParams.meshShrinker(),
+                combinedDict,
+                internalBaffles,
+                displacement
+            );
         }
 
-        // Truncate displacements that are too small (this will do internal
-        // ones, coupled ones have already been truncated by
-        // syncPatchDisplacement)
-        faceSet dummySet(mesh, "wrongPatchFaces", 0);
-        truncateDisplacement
+
+        // Saved old points
+        const pointField oldPoints(mesh.points());
+
+        for
         (
-            globalFaces,
-            edgeGlobalFaces,
-            pp,
-            minThickness,
-            dummySet,
-            patchDisp,
-            patchNLayers,
-            extrudeStatus
-        );
-
-
-        // Dump to .obj file for debugging.
-        if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
+            label iteration = 0;
+            iteration < layerParams.nLayerIter();
+            iteration++
+        )
         {
-            dumpDisplacement
+            Info<< nl
+                << "Layer addition iteration " << iteration << nl
+                << "--------------------------" << endl;
+
+
+            // Unset the extrusion at the pp.
+            const dictionary& meshQualityDict =
             (
-                mesh.time().path()/"layer_" + meshRefiner_.timeName(),
-                pp(),
+                iteration < layerParams.nRelaxedIter()
+              ? motionDict
+              : motionDict.subDict("relaxed")
+            );
+
+            if (iteration >= layerParams.nRelaxedIter())
+            {
+                Info<< "Switched to relaxed meshQuality constraints." << endl;
+            }
+
+
+
+            // Make sure displacement is equal on both sides of coupled patches.
+            syncPatchDisplacement
+            (
+                pp,
+                minThickness,
                 patchDisp,
+                patchNLayers,
                 extrudeStatus
             );
 
+            // Displacement acc. to pointnormals
+            getPatchDisplacement
+            (
+                pp,
+                thickness,
+                minThickness,
+                patchDisp,
+                patchNLayers,
+                extrudeStatus
+            );
+
+            // Shrink mesh by displacement value first.
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+            {
+                const pointField oldPatchPos(pp().localPoints());
+
+                // Take over patchDisp into pointDisplacement field and
+                // adjust both for multi-patch constraints
+                motionSmootherAlgo::setDisplacement
+                (
+                    patchIDs,
+                    pp,
+                    patchDisp,
+                    displacement
+                );
+
+
+                // Move mesh
+                // ~~~~~~~~~
+
+                // Set up controls for meshMover
+                dictionary combinedDict(layerParams.dict());
+                // Add standard quality constraints
+                combinedDict.merge(motionDict);
+                // Add relaxed constraints (overrides standard ones)
+                combinedDict.merge(meshQualityDict);
+                // Where to get minThickness from
+                combinedDict.add("minThicknessName", minThickness.name());
+
+                labelList checkFaces(identity(mesh.nFaces()));
+                medialAxisMoverPtr().move
+                (
+                    combinedDict,
+                    nAllowableErrors,
+                    checkFaces
+                );
+
+                pp().movePoints(mesh.points());
+
+                // 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
+            // syncPatchDisplacement)
+            faceSet dummySet(mesh, "wrongPatchFaces", 0);
+            truncateDisplacement
+            (
+                globalFaces,
+                edgeGlobalFaces,
+                pp,
+                minThickness,
+                dummySet,
+                patchDisp,
+                patchNLayers,
+                extrudeStatus
+            );
+
+
+            // Dump to .obj file for debugging.
+            if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
+            {
+                dumpDisplacement
+                (
+                    mesh.time().path()/"layer_" + meshRefiner_.timeName(),
+                    pp(),
+                    patchDisp,
+                    extrudeStatus
+                );
+
+                const_cast<Time&>(mesh.time())++;
+                Info<< "Writing shrunk mesh to time "
+                    << meshRefiner_.timeName() << endl;
+
+                // See comment in autoSnapDriver why we should not remove
+                // meshPhi using mesh.clearOut().
+
+                meshRefiner_.write
+                (
+                    meshRefinement::debugType(debug),
+                    meshRefinement::writeType
+                    (
+                        meshRefinement::writeLevel()
+                      | meshRefinement::WRITEMESH
+                    ),
+                    mesh.time().path()/meshRefiner_.timeName()
+                );
+            }
+
+
+            // 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().size(), -1);
+            setupLayerInfoTruncation
+            (
+                pp,
+                patchNLayers,
+                extrudeStatus,
+                layerParams.nBufferCellsNoExtrude(),
+                nPatchPointLayers,
+                nPatchFaceLayers
+            );
+
+            // Calculate displacement for final layer for addPatchLayer.
+            // (layer of cells next to the original mesh)
+            vectorField finalDisp(patchNLayers.size(), vector::zero);
+
+            forAll(nPatchPointLayers, i)
+            {
+                scalar ratio = layerParams.finalLayerThicknessRatio
+                (
+                    nPatchPointLayers[i],
+                    expansionRatio[i]
+                );
+                finalDisp[i] = ratio*patchDisp[i];
+            }
+
+
+            const scalarField invExpansionRatio(1.0/expansionRatio);
+
+            // Add topo regardless of whether extrudeStatus is extruderemove.
+            // Not add layer if patchDisp is zero.
+            addLayer.setRefinement
+            (
+                globalFaces,
+                edgeGlobalFaces,
+
+                invExpansionRatio,
+                pp(),
+                sidePatchID,    // boundary patch for extruded boundary edges
+                labelList(0),   // exposed patchIDs, not used for adding layers
+                nPatchFaceLayers,   // layers per face
+                nPatchPointLayers,  // layers per point
+                finalDisp,      // thickness of layer nearest internal mesh
+                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.time(),  // register with runTime
+                    IOobject::NO_READ,
+                    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);
+
+            newMesh.setInstance(meshRefiner_.timeName());
+
+            // 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,
+                avgPointData(pp, mag(patchDisp))(), // current thickness
+
+                cellNLayers,
+                faceRealThickness
+            );
+
+
+            // Count number of added cells
+            label nAddedCells = 0;
+            forAll(cellNLayers, cellI)
+            {
+                if (cellNLayers[cellI] > 0)
+                {
+                    nAddedCells++;
+                }
+            }
+
+
+            if (debug&meshRefinement::MESH)
+            {
+                Info<< "Writing layer mesh to time " << meshRefiner_.timeName()
+                    << endl;
+                newMesh.write();
+                writeLayerSets(newMesh, cellNLayers, faceRealThickness);
+
+                // Reset the instance of the original mesh so next iteration
+                // it dumps a complete mesh. This is just so that the inbetween
+                // newMesh does not upset e.g. paraFoam cycling through the
+                // times.
+                mesh.setInstance(meshRefiner_.timeName());
+            }
+
+
+            const List<labelPair> internalBaffles
+            (
+                meshRefinement::subsetBaffles
+                (
+                    newMesh,
+                    internalFaceZones,
+                    localPointRegion::findDuplicateFacePairs(newMesh)
+                )
+            );
+
+            label nTotChanged = checkAndUnmark
+            (
+                addLayer,
+                meshQualityDict,
+                layerParams.additionalReporting(),
+                internalBaffles,
+                pp(),
+                newMesh,
+
+                patchDisp,
+                patchNLayers,
+                extrudeStatus
+            );
+
+            label nTotExtruded = countExtrusion(pp, extrudeStatus);
+            label nTotFaces = returnReduce(pp().size(), sumOp<label>());
+            label nTotAddedCells = returnReduce(nAddedCells, sumOp<label>());
+
+            Info<< "Extruding " << nTotExtruded
+                << " out of " << nTotFaces
+                << " faces (" << 100.0*nTotExtruded/nTotFaces << "%)."
+                << " Removed extrusion at " << nTotChanged << " faces."
+                << endl
+                << "Added " << nTotAddedCells << " out of "
+                << nIdealTotAddedCells
+                << " cells (" << 100.0*nTotAddedCells/nIdealTotAddedCells
+                << "%)." << endl;
+
+            if (nTotChanged == 0)
+            {
+                break;
+            }
+
+            // Reset mesh points and start again
+            mesh.movePoints(oldPoints);
+            pp().movePoints(mesh.points());
+
+            // Grow out region of non-extrusion
+            for (label i = 0; i < layerParams.nGrow(); i++)
+            {
+                growNoExtrusion
+                (
+                    pp,
+                    patchDisp,
+                    patchNLayers,
+                    extrudeStatus
+                );
+            }
+
+            Info<< endl;
+        }
+    }
+
+
+    // 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);
+
+        // Hack to remove meshPhi - mapped incorrectly. TBD.
+        mesh.clearOut();
+
+        // Update fields
+        mesh.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes.
+            mesh.clearOut();
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh.setInstance(meshRefiner_.timeName());
+
+        meshRefiner_.updateMesh(map, labelList(0));
+
+        // Update numbering of faceWantedThickness
+        meshRefinement::updateList
+        (
+            map().faceMap(),
+            scalar(0),
+            faceWantedThickness
+        );
+
+        // Print data now that we still have patches for the zones
+        //if (meshRefinement::outputLevel() & meshRefinement::OUTPUTLAYERINFO)
+        printLayerData
+        (
+            mesh,
+            patchIDs,
+            cellNLayers,
+            faceWantedThickness,
+            faceRealThickness
+        );
+
+
+        // Dump for debugging
+        if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
+        {
             const_cast<Time&>(mesh.time())++;
-            Info<< "Writing shrunk mesh to time "
+            Info<< "Writing mesh with layers but disconnected to time "
                 << meshRefiner_.timeName() << endl;
-
-            // See comment in autoSnapDriver why we should not remove meshPhi
-            // using mesh.clearOut().
-
             meshRefiner_.write
             (
                 meshRefinement::debugType(debug),
@@ -3252,288 +3827,192 @@ void Foam::autoLayerDriver::addLayers
         }
 
 
-        // 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().size(), -1);
-        setupLayerInfoTruncation
-        (
-            pp,
-            patchNLayers,
-            extrudeStatus,
-            layerParams.nBufferCellsNoExtrude(),
-            nPatchPointLayers,
-            nPatchFaceLayers
-        );
-
-        // Calculate displacement for final layer for addPatchLayer.
-        // (layer of cells next to the original mesh)
-        vectorField finalDisp(patchNLayers.size(), vector::zero);
-
-        forAll(nPatchPointLayers, i)
+        // Update numbering of pointToDuplicate
         {
-            scalar ratio = layerParams.finalLayerThicknessRatio
-            (
-                nPatchPointLayers[i],
-                expansionRatio[i]
-            );
-            finalDisp[i] = ratio*patchDisp[i];
-        }
+            // The problem is that pointToDuplicate is valid for the old
+            // boundary points which are now internal. We need to find the
+            // corresponding new boundary point.
 
-
-        const scalarField invExpansionRatio(1.0/expansionRatio);
-
-        // Add topo regardless of whether extrudeStatus is extruderemove.
-        // Not add layer if patchDisp is zero.
-        addLayer.setRefinement
-        (
-            globalFaces,
-            edgeGlobalFaces,
-
-            invExpansionRatio,
-            pp(),
-            sidePatchID,        // boundary patch for extruded boundary edges
-            labelList(0),       // exposed patchIDs, not used for adding layers
-            nPatchFaceLayers,   // layers per face
-            nPatchPointLayers,  // layers per point
-            finalDisp,          // thickness of layer nearest internal mesh
-            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.time(),  // register with runTime
-                IOobject::NO_READ,
-                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);
-
-        newMesh.setInstance(meshRefiner_.timeName());
-
-        // 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())
-        );
-
-        // Update numbering of baffles
-        List<labelPair> newMeshBaffles(baffles.size());
-        forAll(baffles, i)
-        {
-            const labelPair& p = baffles[i];
-            newMeshBaffles[i][0] = map().reverseFaceMap()[p[0]];
-            newMeshBaffles[i][1] = map().reverseFaceMap()[p[1]];
-        }
-
-        // Collect layer faces and cells for outside loop.
-        getLayerCellsFaces
-        (
-            newMesh,
-            addLayer,
-            avgPointData(pp, mag(patchDisp))(), // current thickness
-
-            cellNLayers,
-            faceRealThickness
-        );
-
-
-        // Count number of added cells
-        label nAddedCells = 0;
-        forAll(cellNLayers, cellI)
-        {
-            if (cellNLayers[cellI] > 0)
+            label nPointPairs = 0;
+            forAll(pointToDuplicate, oldPointI)
             {
-                nAddedCells++;
-            }
-        }
-
-
-        if (debug&meshRefinement::MESH)
-        {
-            Info<< "Writing layer mesh to time " << meshRefiner_.timeName()
-                << endl;
-            newMesh.write();
-
-            cellSet addedCellSet(newMesh, "addedCells", nAddedCells);
-            forAll(cellNLayers, cellI)
-            {
-                if (cellNLayers[cellI] > 0)
+                label otherOldPointI = pointToDuplicate[oldPointI];
+                if (otherOldPointI != -1)
                 {
-                    addedCellSet.insert(cellI);
+                    nPointPairs++;
                 }
             }
-            addedCellSet.instance() = meshRefiner_.timeName();
-            Info<< "Writing "
-                << returnReduce(addedCellSet.size(), sumOp<label>())
-                << " added cells to cellSet " << addedCellSet.name() << endl;
-            addedCellSet.write();
 
-            faceSet layerFacesSet(newMesh, "layerFaces", newMesh.nFaces()/100);
-            for (label faceI = 0; faceI < newMesh.nInternalFaces(); faceI++)
+            const labelList& pointMap = map().pointMap();
+
+            // 1. Construct map from old (possibly) internal point to
+            //    new boundary point
+            Map<label> oldPointToBoundaryPoint(2*nPointPairs);
+
+            forAll(internalOrBaffleFaceZones, i)
             {
-                if (faceRealThickness[faceI] > 0)
+                label zoneI = internalOrBaffleFaceZones[i];
+                const faceZone& fz = mesh.faceZones()[zoneI];
+                forAll(fz, j)
                 {
-                    layerFacesSet.insert(faceI);
+                    const face& f = mesh.faces()[fz[j]];
+                    forAll(f, fp)
+                    {
+                        label pointI = f[fp];
+                        label oldPointI = pointMap[pointI];
+                        if (pointToDuplicate[oldPointI] != -1)
+                        {
+                            oldPointToBoundaryPoint.insert(oldPointI, pointI);
+                        }
+                    }
+                }
+            }
+
+
+            // 2. Pick up old internal point
+
+            labelList oldPointToDuplicate(pointToDuplicate.xfer());
+            pointToDuplicate.setSize(mesh.nPoints(), -1);
+
+            forAll(internalOrBaffleFaceZones, i)
+            {
+                label zoneI = internalOrBaffleFaceZones[i];
+                const faceZone& fz = mesh.faceZones()[zoneI];
+                forAll(fz, j)
+                {
+                    const face& f = mesh.faces()[fz[j]];
+                    forAll(f, fp)
+                    {
+                        label oldPointI = pointMap[f[fp]];
+                        label oldDupI = oldPointToDuplicate[oldPointI];
+                        if (oldDupI != -1)
+                        {
+                            pointToDuplicate[f[fp]] =
+                                oldPointToBoundaryPoint[oldDupI];
+                        }
+                    }
+                }
+            }
+
+
+
+            // Check
+            forAll(pointToDuplicate, pointI)
+            {
+                label dupI = pointToDuplicate[pointI];
+                if (dupI != -1)
+                {
+                    const point& pt = mesh.points()[pointI];
+                    const point& dupPt = mesh.points()[dupI];
+                    if (mag(pt-dupPt) > meshRefiner_.mergeDistance())
+                    {
+                        WarningIn("autoLayerDriver::addLayers(..)")
+                            << "Trying to merge points "
+                            << pointI << " at:" << pt
+                            << "and " << dupI << " at:" << dupPt
+                            << " distance " << mag(pt-dupPt)
+                            << endl;
+                    }
                 }
             }
-            layerFacesSet.instance() = meshRefiner_.timeName();
-            Info<< "Writing "
-                << returnReduce(layerFacesSet.size(), sumOp<label>())
-                << " faces inside added layer to faceSet "
-                << layerFacesSet.name() << endl;
-            layerFacesSet.write();
         }
+    }
 
-
-        label nTotChanged = checkAndUnmark
-        (
-            addLayer,
-            meshQualityDict,
-            layerParams.additionalReporting(),
-            newMeshBaffles,
-            pp(),
-            newMesh,
-
-            patchDisp,
-            patchNLayers,
-            extrudeStatus
-        );
-
-        label nTotExtruded = countExtrusion(pp, extrudeStatus);
-        label nTotFaces = returnReduce(pp().size(), sumOp<label>());
-        label nTotAddedCells = returnReduce(nAddedCells, sumOp<label>());
-
-        Info<< "Extruding " << nTotExtruded
-            << " out of " << nTotFaces
-            << " faces (" << 100.0*nTotExtruded/nTotFaces << "%)."
-            << " Removed extrusion at " << nTotChanged << " faces."
-            << endl
-            << "Added " << nTotAddedCells << " out of " << nIdealTotAddedCells
-            << " cells (" << 100.0*nTotAddedCells/nIdealTotAddedCells << "%)."
-            << endl;
-
-        if (nTotChanged == 0)
+    // Count duplicate points
+    label nPointPairs = 0;
+    forAll(pointToDuplicate, pointI)
+    {
+        label otherPointI = pointToDuplicate[pointI];
+        if (otherPointI != -1)
         {
-            break;
+            nPointPairs++;
         }
+    }
+    reduce(nPointPairs, sumOp<label>());
+    if (nPointPairs > 0)
+    {
+        // Merge any duplicated points
+        Info<< "Merging " << nPointPairs << " duplicated points ..." << endl;
 
-        // Reset mesh points and start again
-        mesh.movePoints(oldPoints);
-        pp().movePoints(mesh.points());
-
-        // Grow out region of non-extrusion
-        for (label i = 0; i < layerParams.nGrow(); i++)
+        if (debug&meshRefinement::MESH || debug&meshRefinement::LAYERINFO)
         {
-            growNoExtrusion
+            OBJstream str
             (
-                pp,
-                patchDisp,
-                patchNLayers,
-                extrudeStatus
+                mesh.time().path()
+              / "mergePoints_"
+              + meshRefiner_.timeName()
+              + ".obj"
             );
+            Info<< "Points to be merged to " << str.name() << endl;
+            forAll(pointToDuplicate, pointI)
+            {
+                label otherPointI = pointToDuplicate[pointI];
+                if (otherPointI != -1)
+                {
+                    const point& pt = mesh.points()[pointI];
+                    const point& otherPt = mesh.points()[otherPointI];
+                    str.write(linePointRef(pt, otherPt));
+                }
+            }
         }
 
-        Info<< endl;
+
+        autoPtr<mapPolyMesh> map = meshRefiner_.mergePoints(pointToDuplicate);
+        if (map.valid())
+        {
+            inplaceReorder(map().reverseCellMap(), cellNLayers);
+
+            const labelList& reverseFaceMap = map().reverseFaceMap();
+            inplaceReorder(reverseFaceMap, faceWantedThickness);
+            inplaceReorder(reverseFaceMap, faceRealThickness);
+
+            Info<< "Merged points in = "
+                << mesh.time().cpuTimeIncrement() << " s\n" << nl << endl;
+        }
     }
 
-
-    // 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);
-
-    // Hack to remove meshPhi - mapped incorrectly. TBD.
-    mesh.clearOut();
-
-    // Update fields
-    mesh.updateMesh(map);
-
-    // Move mesh (since morphing does not do this)
-    if (map().hasMotionPoints())
-    {
-        mesh.movePoints(map().preMotionPoints());
-    }
-    else
-    {
-        // Delete mesh volumes.
-        mesh.clearOut();
-    }
-
-    // Reset the instance for if in overwrite mode
-    mesh.setInstance(meshRefiner_.timeName());
-
-    meshRefiner_.updateMesh(map, labelList(0));
-
-    // Update numbering of faceWantedThickness
-    meshRefinement::updateList(map().faceMap(), scalar(0), faceWantedThickness);
-
-    // Update numbering on baffles
-    forAll(baffles, i)
-    {
-        labelPair& p = baffles[i];
-        p[0] = map().reverseFaceMap()[p[0]];
-        p[1] = map().reverseFaceMap()[p[1]];
-    }
-
-
-    label nBaffles = returnReduce(baffles.size(), sumOp<label>());
-    if (nBaffles > 0)
+    if (mesh.faceZones().size() > 0)
     {
         // Merge any baffles
-        Info<< "Converting " << nBaffles
-            << " baffles back into zoned faces ..."
+        Info<< "Converting baffles back into zoned faces ..."
             << endl;
 
-        autoPtr<mapPolyMesh> map = meshRefiner_.mergeBaffles(baffles);
+        autoPtr<mapPolyMesh> map = meshRefiner_.mergeZoneBaffles
+        (
+            true,   // internal zones
+            false   // baffle zones
+        );
+        if (map.valid())
+        {
+            inplaceReorder(map().reverseCellMap(), cellNLayers);
 
-        inplaceReorder(map().reverseCellMap(), cellNLayers);
-        inplaceReorder(map().reverseFaceMap(), faceWantedThickness);
-        inplaceReorder(map().reverseFaceMap(), faceRealThickness);
+            const labelList& faceMap = map().faceMap();
+
+            // Make sure to keep the max since on two patches only one has
+            // layers.
+            scalarField newFaceRealThickness(mesh.nFaces(), 0.0);
+            scalarField newFaceWantedThickness(mesh.nFaces(), 0.0);
+            forAll(newFaceRealThickness, faceI)
+            {
+                label oldFaceI = faceMap[faceI];
+                if (oldFaceI >= 0)
+                {
+                    scalar& realThick = newFaceRealThickness[faceI];
+                    realThick = max(realThick, faceRealThickness[oldFaceI]);
+                    scalar& wanted = newFaceWantedThickness[faceI];
+                    wanted = max(wanted, faceWantedThickness[oldFaceI]);
+                }
+            }
+            faceRealThickness.transfer(newFaceRealThickness);
+            faceWantedThickness.transfer(newFaceWantedThickness);
+        }
 
         Info<< "Converted baffles in = "
             << meshRefiner_.mesh().time().cpuTimeIncrement()
             << " s\n" << nl << endl;
     }
 
-
     // Do final balancing
     // ~~~~~~~~~~~~~~~~~~
 
@@ -3585,6 +4064,7 @@ void Foam::autoLayerDriver::doLayers
     const dictionary& shrinkDict,
     const dictionary& motionDict,
     const layerParameters& layerParams,
+    const bool mergePatchFaces,
     const bool preBalance,
     decompositionMethod& decomposer,
     fvMeshDistribute& distributor
@@ -3597,10 +4077,15 @@ void Foam::autoLayerDriver::doLayers
         << "----------------------------------" << nl
         << endl;
 
+
     Info<< "Using mesh parameters " << motionDict << nl << endl;
 
     // Merge coplanar boundary faces
-    mergePatchFacesUndo(layerParams, motionDict);
+    if (mergePatchFaces)
+    {
+        mergePatchFacesUndo(layerParams, motionDict);
+    }
+
 
     // Per patch the number of layers (-1 or 0 if no layer)
     const labelList& numLayers = layerParams.numLayers();
@@ -3627,6 +4112,26 @@ void Foam::autoLayerDriver::doLayers
             }
         }
     }
+
+    // Add contributions from faceZones that get layers
+    const faceZoneMesh& fZones = mesh.faceZones();
+    forAll(fZones, zoneI)
+    {
+        label mpI, spI;
+        surfaceZonesInfo::faceZoneType fzType;
+        meshRefiner_.getFaceZoneInfo(fZones[zoneI].name(), mpI, spI, fzType);
+
+        if (numLayers[mpI] > 0)
+        {
+            nFacesWithLayers += fZones[zoneI].size();
+        }
+        if (numLayers[spI] > 0)
+        {
+            nFacesWithLayers += fZones[zoneI].size();
+        }
+    }
+
+
     patchIDs.shrink();
 
     if (returnReduce(nFacesWithLayers, sumOp<label>()) == 0)
@@ -3674,12 +4179,45 @@ void Foam::autoLayerDriver::doLayers
                 }
             }
 
+            // Add contributions from faceZones that get layers
+            const faceZoneMesh& fZones = mesh.faceZones();
+            forAll(fZones, zoneI)
+            {
+                const faceZone& fZone = fZones[zoneI];
+                const word& fzName = fZone.name();
+
+                label mpI, spI;
+                surfaceZonesInfo::faceZoneType fzType;
+                meshRefiner_.getFaceZoneInfo(fzName, mpI, spI, fzType);
+
+                if (numLayers[mpI] > 0)
+                {
+                    // Get the owner side for unflipped faces, neighbour side
+                    // for flipped ones
+                    const labelList& cellIDs = fZone.slaveCells();
+                    forAll(cellIDs, i)
+                    {
+                        cellWeights[cellIDs[i]] += numLayers[mpI];
+                    }
+                }
+                if (numLayers[spI] > 0)
+                {
+                    const labelList& cellIDs = fZone.masterCells();
+                    forAll(cellIDs, i)
+                    {
+                        cellWeights[cellIDs[i]] += numLayers[mpI];
+                    }
+                }
+            }
+
+
+
             // Balance mesh (and meshRefinement). Restrict faceZones to
             // be on internal faces only since they will be converted into
             // baffles.
             autoPtr<mapDistributePolyMesh> map = meshRefiner_.balance
             (
-                true,   //false,    // keepZoneFaces
+                true,           // keepZoneFaces
                 false,
                 cellWeights,
                 decomposer,
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
index ee94b0b015..85ac62e77a 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -109,7 +109,6 @@ private:
         const labelList globalToSlavePatch_;
 
 
-
     // Private Member Functions
 
         // Layers
@@ -371,6 +370,14 @@ private:
                     const List<extrudeMode>& extrudeStatus
                 );
 
+                //- After adding to mesh get the new baffles
+                static List<labelPair> getBafflesOnAddedMesh
+                (
+                    const polyMesh& mesh,
+                    const labelList& newToOldFaces,
+                    const List<labelPair>& baffles
+                );
+
                 //- Collect layer faces and layer cells into bools
                 //  for ease of handling
                 static void getLayerCellsFaces
@@ -394,6 +401,15 @@ private:
                 ) const;
 
                 //- Write cellSet,faceSet for layers
+                bool writeLayerSets
+                (
+                    const fvMesh& mesh,
+                    const labelList& cellNLayers,
+                    const scalarField& faceRealThickness
+                ) const;
+
+                //- Write volFields,cellSet,faceSet for layers depending
+                //  on write level
                 bool writeLayerData
                 (
                     const fvMesh& mesh,
@@ -596,6 +612,7 @@ public:
                 const dictionary& shrinkDict,
                 const dictionary& motionDict,
                 const layerParameters& layerParams,
+                const bool mergePatchFaces,         // merging patch faces
                 const bool preBalance,              // balance before adding?
                 decompositionMethod& decomposer,
                 fvMeshDistribute& distributor
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
index 48fcdbbb06..442e34813d 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C
@@ -37,6 +37,7 @@ License
 #include "unitConversion.H"
 #include "snapParameters.H"
 #include "localPointRegion.H"
+#include "IOmanip.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -94,7 +95,7 @@ Foam::label Foam::autoRefineDriver::featureEdgeRefine
             (
                 meshRefiner_.refineCandidates
                 (
-                    refineParams.keepPoints(),
+                    refineParams.locationsInMesh(),
                     refineParams.curvature(),
                     refineParams.planarAngle(),
 
@@ -207,7 +208,7 @@ Foam::label Foam::autoRefineDriver::surfaceOnlyRefine
         (
             meshRefiner_.refineCandidates
             (
-                refineParams.keepPoints(),
+                refineParams.locationsInMesh(),
                 refineParams.curvature(),
                 refineParams.planarAngle(),
 
@@ -341,7 +342,7 @@ Foam::label Foam::autoRefineDriver::gapOnlyRefine
         (
             meshRefiner_.refineCandidates
             (
-                refineParams.keepPoints(),
+                refineParams.locationsInMesh(),
                 refineParams.curvature(),
                 refineParams.planarAngle(),
 
@@ -692,7 +693,9 @@ void Foam::autoRefineDriver::removeInsideCells
         nBufferLayers,                  // nBufferLayers
         globalToMasterPatch_,
         globalToSlavePatch_,
-        refineParams.keepPoints()[0]
+        refineParams.locationsInMesh(),
+        refineParams.zonesInMesh(),
+        refineParams.locationsOutsideMesh()
     );
 
     if (debug&meshRefinement::MESH)
@@ -753,7 +756,7 @@ Foam::label Foam::autoRefineDriver::shellRefine
         (
             meshRefiner_.refineCandidates
             (
-                refineParams.keepPoints(),
+                refineParams.locationsInMesh(),
                 refineParams.curvature(),
                 refineParams.planarAngle(),
 
@@ -921,14 +924,17 @@ void Foam::autoRefineDriver::baffleAndSplitMesh
         const_cast<Time&>(mesh.time()),
         globalToMasterPatch_,
         globalToSlavePatch_,
-        refineParams.keepPoints()[0]
+        refineParams.locationsInMesh(),
+        refineParams.zonesInMesh(),
+        refineParams.locationsOutsideMesh()
     );
 }
 
 
 void Foam::autoRefineDriver::zonify
 (
-    const refinementParameters& refineParams
+    const refinementParameters& refineParams,
+    wordPairHashTable& zonesToFaceZone
 )
 {
     // Mesh is at its finest. Do zoning
@@ -940,7 +946,11 @@ void Foam::autoRefineDriver::zonify
     const labelList namedSurfaces =
         surfaceZonesInfo::getNamedSurfaces(meshRefiner_.surfaces().surfZones());
 
-    if (namedSurfaces.size())
+    if
+    (
+        namedSurfaces.size()
+     || refineParams.zonesInMesh().size()
+    )
     {
         Info<< nl
             << "Introducing zones for interfaces" << nl
@@ -956,8 +966,10 @@ void Foam::autoRefineDriver::zonify
 
         meshRefiner_.zonify
         (
-            refineParams.keepPoints()[0],
-            refineParams.allowFreeStandingZoneFaces()
+            refineParams.allowFreeStandingZoneFaces(),
+            refineParams.locationsInMesh(),
+            refineParams.zonesInMesh(),
+            zonesToFaceZone
         );
 
         if (debug&meshRefinement::MESH)
@@ -1023,7 +1035,9 @@ void Foam::autoRefineDriver::splitAndMergeBaffles
         const_cast<Time&>(mesh.time()),
         globalToMasterPatch_,
         globalToSlavePatch_,
-        refineParams.keepPoints()[0]
+        refineParams.locationsInMesh(),
+        refineParams.zonesInMesh(),
+        refineParams.locationsOutsideMesh()
     );
 
     if (debug)
@@ -1061,7 +1075,8 @@ void Foam::autoRefineDriver::splitAndMergeBaffles
         (
             globalToMasterPatch_,
             globalToSlavePatch_,
-            refineParams.keepPoints()[0]
+            refineParams.locationsInMesh(),
+            refineParams.locationsOutsideMesh()
         );
 
         if (debug)
@@ -1092,8 +1107,82 @@ void Foam::autoRefineDriver::splitAndMergeBaffles
 }
 
 
+void Foam::autoRefineDriver::addFaceZones
+(
+    meshRefinement& meshRefiner,
+    const refinementParameters& refineParams,
+    const wordPairHashTable& zonesToFaceZone
+)
+{
+    if (zonesToFaceZone.size())
+    {
+        Info<< nl
+            << "Adding patches for inter-region zones" << nl
+            << "-------------------------------------" << nl
+            << endl;
+
+        Info<< setf(ios_base::left)
+            << setw(6) << "Patch"
+            << setw(20) << "Type"
+            << setw(30) << "Name"
+            << setw(30) << "FaceZone"
+            << setw(10) << "FaceType"
+            << nl
+            << setw(6) << "-----"
+            << setw(20) << "----"
+            << setw(30) << "----"
+            << setw(30) << "--------"
+            << setw(10) << "--------"
+            << endl;
+
+        const polyMesh& mesh = meshRefiner.mesh();
+
+        // Add patches for added inter-region faceZones
+        forAllConstIter(wordPairHashTable, zonesToFaceZone, iter)
+        {
+            const Pair<word>& czNames = iter.key();
+            const word& fzName = iter();
+
+            // Get any user-defined faceZone data
+            surfaceZonesInfo::faceZoneType fzType;
+            dictionary patchInfo = refineParams.getZoneInfo(fzName, fzType);
+
+            const word& masterName = fzName;
+            //const word slaveName = fzName + "_slave";
+            const word slaveName = czNames.second() + "_to_" + czNames.first();
+
+            label mpI = meshRefiner.addMeshedPatch(masterName, patchInfo);
+
+            Info<< setf(ios_base::left)
+                << setw(6) << mpI
+                << setw(20) << mesh.boundaryMesh()[mpI].type()
+                << setw(30) << masterName
+                << setw(30) << fzName
+                << setw(10) << surfaceZonesInfo::faceZoneTypeNames[fzType]
+                << nl;
+
+
+            label slI = meshRefiner.addMeshedPatch(slaveName, patchInfo);
+
+            Info<< setf(ios_base::left)
+                << setw(6) << slI
+                << setw(20) << mesh.boundaryMesh()[slI].type()
+                << setw(30) << slaveName
+                << setw(30) << fzName
+                << setw(10) << surfaceZonesInfo::faceZoneTypeNames[fzType]
+                << nl;
+
+            meshRefiner.addFaceZone(fzName, masterName, slaveName, fzType);
+        }
+
+        Info<< endl;
+    }
+}
+
+
 void Foam::autoRefineDriver::mergePatchFaces
 (
+    const bool keepHex,
     const refinementParameters& refineParams,
     const dictionary& motionDict
 )
@@ -1105,14 +1194,27 @@ void Foam::autoRefineDriver::mergePatchFaces
 
     const fvMesh& mesh = meshRefiner_.mesh();
 
-    meshRefiner_.mergePatchFacesUndo
-    (
-        Foam::cos(degToRad(45.0)),
-        Foam::cos(degToRad(45.0)),
-        meshRefiner_.meshedPatches(),
-        motionDict,
-        labelList(mesh.nFaces(), -1)
-    );
+    if (keepHex)
+    {
+        meshRefiner_.mergePatchFaces
+        (
+            Foam::cos(degToRad(45.0)),
+            Foam::cos(degToRad(45.0)),
+            4,          // only merge faces split into 4
+            meshRefiner_.meshedPatches()
+        );
+    }
+    else
+    {
+        meshRefiner_.mergePatchFacesUndo
+        (
+            Foam::cos(degToRad(45.0)),
+            Foam::cos(degToRad(45.0)),
+            meshRefiner_.meshedPatches(),
+            motionDict,
+            labelList(mesh.nFaces(), -1)
+        );
+    }
 
     if (debug)
     {
@@ -1134,6 +1236,7 @@ void Foam::autoRefineDriver::doRefine
     const refinementParameters& refineParams,
     const snapParameters& snapParams,
     const bool prepareForSnapping,
+    const bool keepHex,
     const dictionary& motionDict
 )
 {
@@ -1145,7 +1248,7 @@ void Foam::autoRefineDriver::doRefine
     const fvMesh& mesh = meshRefiner_.mesh();
 
     // Check that all the keep points are inside the mesh.
-    refineParams.findCells(mesh);
+    refineParams.findCells(true, mesh, refineParams.locationsInMesh());
 
     // Refine around feature edges
     featureEdgeRefine
@@ -1206,8 +1309,12 @@ void Foam::autoRefineDriver::doRefine
         motionDict
     );
 
-    // Mesh is at its finest. Do optional zoning.
-    zonify(refineParams);
+    // Mesh is at its finest. Do optional zoning (cellZones and faceZones)
+    wordPairHashTable zonesToFaceZone;
+    zonify(refineParams, zonesToFaceZone);
+
+    // Create pairs of patches for faceZones
+    addFaceZones(meshRefiner_, refineParams, zonesToFaceZone);
 
     // Pull baffles apart
     splitAndMergeBaffles
@@ -1221,7 +1328,7 @@ void Foam::autoRefineDriver::doRefine
     // Do something about cells with refined faces on the boundary
     if (prepareForSnapping)
     {
-        mergePatchFaces(refineParams, motionDict);
+        mergePatchFaces(keepHex, refineParams, motionDict);
     }
 
 
@@ -1232,19 +1339,14 @@ void Foam::autoRefineDriver::doRefine
             << "---------------------" << nl
             << endl;
 
-        //if (debug)
-        //{
-        //    const_cast<Time&>(mesh.time())++;
-        //}
-
         // Do final balancing. Keep zoned faces on one processor since the
         // snap phase will convert them to baffles and this only works for
         // internal faces.
         meshRefiner_.balance
         (
-            true,
-            false,
-            scalarField(mesh.nCells(), 1), // dummy weights
+            true,                           // keepZoneFaces
+            false,                          // keepBaffles
+            scalarField(mesh.nCells(), 1),  // cellWeights
             decomposer_,
             distributor_
         );
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
index a72f3c0796..39545b9deb 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,8 @@ SourceFiles
 #ifndef autoRefineDriver_H
 #define autoRefineDriver_H
 
-#include "treeBoundBox.H"
+#include "wordPairHashTable.H"
+#include "labelList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -129,7 +130,11 @@ class autoRefineDriver
         );
 
         //- Add zones
-        void zonify(const refinementParameters& refineParams);
+        void zonify
+        (
+            const refinementParameters& refineParams,
+            wordPairHashTable& zonesToFaceZone
+        );
 
         void splitAndMergeBaffles
         (
@@ -142,11 +147,11 @@ class autoRefineDriver
         //- Merge refined boundary faces (from exposing coarser cell)
         void mergePatchFaces
         (
+            const bool keepHex,
             const refinementParameters& refineParams,
             const dictionary& motionDict
         );
 
-
         //- Disallow default bitwise copy construct
         autoRefineDriver(const autoRefineDriver&);
 
@@ -182,8 +187,18 @@ public:
             const refinementParameters& refineParams,
             const snapParameters& snapParams,
             const bool prepareForSnapping,
+            const bool keepHexOnly,
             const dictionary& motionDict
         );
+
+        //- Helper: add faceZones and patches
+        static void addFaceZones
+        (
+            meshRefinement& meshRefiner,
+            const refinementParameters& refineParams,
+            const wordPairHashTable& zonesToFaceZone
+        );
+
 };
 
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
index e810b198f4..a9d6ad4f64 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
@@ -43,6 +43,7 @@ Description
 #include "unitConversion.H"
 #include "localPointRegion.H"
 #include "PatchTools.H"
+#include "refinementFeatures.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -648,35 +649,6 @@ Foam::autoSnapDriver::autoSnapDriver
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::mapPolyMesh> Foam::autoSnapDriver::mergeZoneBaffles
-(
-    const List<labelPair>& baffles
-)
-{
-    labelList zonedSurfaces =
-        surfaceZonesInfo::getNamedSurfaces(meshRefiner_.surfaces().surfZones());
-
-    autoPtr<mapPolyMesh> map;
-
-    // No need to sync; all processors will have all same zonedSurfaces.
-    label nBaffles = returnReduce(baffles.size(), sumOp<label>());
-    if (zonedSurfaces.size() && 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 fvMesh& mesh,
@@ -2454,10 +2426,45 @@ void Foam::autoSnapDriver::detectWarpedFaces
 }
 
 
+Foam::labelList Foam::autoSnapDriver::getInternalOrBaffleDuplicateFace() const
+{
+    const fvMesh& mesh = meshRefiner_.mesh();
+
+    labelList internalOrBaffleFaceZones;
+    {
+        List<surfaceZonesInfo::faceZoneType> fzTypes(2);
+        fzTypes[0] = surfaceZonesInfo::INTERNAL;
+        fzTypes[1] = surfaceZonesInfo::BAFFLE;
+        internalOrBaffleFaceZones = meshRefiner_.getZones(fzTypes);
+    }
+
+    List<labelPair> baffles
+    (
+        meshRefiner_.subsetBaffles
+        (
+            mesh,
+            internalOrBaffleFaceZones,
+            localPointRegion::findDuplicateFacePairs(mesh)
+        )
+    );
+
+    labelList faceToDuplicate(mesh.nFaces(), -1);
+    forAll(baffles, i)
+    {
+        const labelPair& p = baffles[i];
+        faceToDuplicate[p[0]] = p[1];
+        faceToDuplicate[p[1]] = p[0];
+    }
+
+    return faceToDuplicate;
+}
+
+
 void Foam::autoSnapDriver::doSnap
 (
     const dictionary& snapDict,
     const dictionary& motionDict,
+    const bool mergePatchFaces,
     const scalar featureCos,
     const scalar planarAngle,
     const snapParameters& snapParams
@@ -2470,10 +2477,6 @@ void Foam::autoSnapDriver::doSnap
         << "--------------" << nl
         << endl;
 
-    // Get the labels of added patches.
-    labelList adaptPatchIDs(meshRefiner_.meshedPatches());
-
-
     // faceZone handling
     // ~~~~~~~~~~~~~~~~~
     //
@@ -2488,223 +2491,55 @@ void Foam::autoSnapDriver::doSnap
     //
     // internal
     // --------
-    // - baffles: contains all faces on faceZone so
-    //      - mesh checks check across baffles
-    //      - they get back merged into internal faces
+    // - baffles: need to be checked across
     // - duplicateFace: from face to duplicate face. Contains
     //   all faces on faceZone to prevents merging patch faces.
     //
     // baffle
     // ------
-    // - baffles: contains no faces on faceZone since need not be merged/checked
-    //   across
+    // - baffles: no need to be checked across
     // - duplicateFace: contains all faces on faceZone to prevent
     //   merging patch faces.
     //
     // boundary
     // --------
-    // - baffles: contains no faces on faceZone since need not be merged/checked
-    //   across
+    // - baffles: no need to be checked across. Also points get duplicated
+    //            so will no longer be baffles
     // - duplicateFace: contains no faces on faceZone since both sides can
     //   merge faces independently.
 
 
-    // Create baffles (pairs of faces that share the same points)
-    // Baffles stored as owner and neighbour face that have been created.
-    List<labelPair> baffles;
-    meshRefiner_.createZoneBaffles
+
+    // faceZones of type internal
+    const labelList internalFaceZones
     (
-        globalToMasterPatch_,
-        globalToSlavePatch_,
-        baffles
+        meshRefiner_.getZones
+        (
+            List<surfaceZonesInfo::faceZoneType>
+            (
+                1,
+                surfaceZonesInfo::INTERNAL
+            )
+        )
     );
 
-    // Maintain map from face to baffle face (-1 for non-baffle faces). Used
-    // later on to prevent patchface merging if faceType=baffle
-    labelList duplicateFace(mesh.nFaces(), -1);
 
-    forAll(baffles, i)
+    // Create baffles (pairs of faces that share the same points)
+    // Baffles stored as owner and neighbour face that have been created.
     {
-        const labelPair& baffle = baffles[i];
-        duplicateFace[baffle.first()] = baffle.second();
-        duplicateFace[baffle.second()] = baffle.first();
-    }
-
-    // Selectively 'forget' about the baffles, i.e. not check across them
-    // or merge across them.
-    {
-        const faceZoneMesh& fZones = mesh.faceZones();
-        const refinementSurfaces& surfaces = meshRefiner_.surfaces();
-        const PtrList<surfaceZonesInfo>& surfZones = surfaces.surfZones();
-
-        // Determine which
-        //  - faces to remove from list of baffles (so not merge)
-        //  - points to duplicate
-
-        // Per face if is on faceType 'baffle' or 'boundary'
-        labelList filterFace(mesh.nFaces(), -1);
-        label nFilterFaces = 0;
-        // Per point whether it need to be duplicated
-        PackedBoolList duplicatePoint(mesh.nPoints());
-        label nDuplicatePoints = 0;
-        forAll(surfZones, surfI)
-        {
-            const word& faceZoneName = surfZones[surfI].faceZoneName();
-
-            if (faceZoneName.size())
-            {
-                const surfaceZonesInfo::faceZoneType& faceType =
-                    surfZones[surfI].faceType();
-
-                if
-                (
-                    faceType == surfaceZonesInfo::BAFFLE
-                 || faceType == surfaceZonesInfo::BOUNDARY
-                )
-                {
-                    // Filter out all faces for this zone.
-                    label zoneI = fZones.findZoneID(faceZoneName);
-                    const faceZone& fZone = fZones[zoneI];
-                    forAll(fZone, i)
-                    {
-                        label faceI = fZone[i];
-                        filterFace[faceI] = zoneI;
-                        nFilterFaces++;
-                    }
-
-                    if (faceType == surfaceZonesInfo::BOUNDARY)
-                    {
-                        forAll(fZone, i)
-                        {
-                            label faceI = fZone[i];
-
-                            // Allow combining patch faces across this face
-                            duplicateFace[faceI] = -1;
-
-                            const face& f = mesh.faces()[faceI];
-                            forAll(f, fp)
-                            {
-                                if (!duplicatePoint[f[fp]])
-                                {
-                                    duplicatePoint[f[fp]] = 1;
-                                    nDuplicatePoints++;
-                                }
-                            }
-                        }
-                    }
-
-                    Info<< "Surface : " << surfaces.names()[surfI] << nl
-                        << "    faces to become baffle : "
-                        << returnReduce(nFilterFaces, sumOp<label>()) << nl
-                        << "    points to duplicate    : "
-                        << returnReduce(nDuplicatePoints, sumOp<label>())
-                        << endl;
-                }
-            }
-        }
-
-        // Duplicate points only if all points agree
-        syncTools::syncPointList
+        List<labelPair> baffles;
+        labelList originatingFaceZone;
+        meshRefiner_.createZoneBaffles
         (
-            mesh,
-            duplicatePoint,
-            andEqOp<unsigned int>(),    // combine op
-            0u                          // null value
+            identity(mesh.faceZones().size()),
+            baffles,
+            originatingFaceZone
         );
-        // Mark as duplicate (avoids combining patch faces) if one or both
-        syncTools::syncFaceList(mesh, duplicateFace, maxEqOp<label>());
-        // Mark as resulting from baffle/boundary face zone only if both agree
-        syncTools::syncFaceList(mesh, filterFace, minEqOp<label>());
-
-        // Duplicate points
-        if (returnReduce(nDuplicatePoints, sumOp<label>()) > 0)
-        {
-            // Collect all points (recount since syncPointList might have
-            // increased set)
-            nDuplicatePoints = 0;
-            forAll(duplicatePoint, pointI)
-            {
-                if (duplicatePoint[pointI])
-                {
-                    nDuplicatePoints++;
-                }
-            }
-            labelList candidatePoints(nDuplicatePoints);
-            nDuplicatePoints = 0;
-            forAll(duplicatePoint, pointI)
-            {
-                if (duplicatePoint[pointI])
-                {
-                    candidatePoints[nDuplicatePoints++] = pointI;
-                }
-            }
-
-
-            localPointRegion regionSide(mesh, candidatePoints);
-            autoPtr<mapPolyMesh> mapPtr = meshRefiner_.dupNonManifoldPoints
-            (
-                regionSide
-            );
-            meshRefinement::updateList(mapPtr().faceMap(), -1, filterFace);
-            meshRefinement::updateList(mapPtr().faceMap(), -1, duplicateFace);
-
-            // Update baffles and baffle-to-baffle addressing
-
-            const labelList& reverseFaceMap = mapPtr().reverseFaceMap();
-
-            forAll(baffles, i)
-            {
-                labelPair& baffle = baffles[i];
-                baffle.first() = reverseFaceMap[baffle.first()];
-                baffle.second() = reverseFaceMap[baffle.second()];
-            }
-
-            if (debug&meshRefinement::MESH)
-            {
-                const_cast<Time&>(mesh.time())++;
-                Pout<< "Writing duplicatedPoints mesh to time "
-                    << meshRefiner_.timeName()
-                    << endl;
-                meshRefiner_.write
-                (
-                    meshRefinement::debugType(debug),
-                    meshRefinement::writeType
-                    (
-                        meshRefinement::writeLevel()
-                      | meshRefinement::WRITEMESH
-                    ),
-                    mesh.time().path()/"duplicatedPoints"
-                );
-            }
-        }
-
-
-        // Forget about baffles in a BAFFLE/BOUNDARY type zone
-        DynamicList<labelPair> newBaffles(baffles.size());
-        forAll(baffles, i)
-        {
-            const labelPair& baffle = baffles[i];
-            if
-            (
-                filterFace[baffle.first()] == -1
-             && filterFace[baffles[i].second()] == -1
-            )
-            {
-                newBaffles.append(baffle);
-            }
-        }
-
-        if (newBaffles.size() < baffles.size())
-        {
-            //Info<< "Splitting baffles into" << nl
-            //    << "    internal : " << newBaffles.size() << nl
-            //    << "    baffle   : " << baffles.size()-newBaffles.size()
-            //    << nl << endl;
-            baffles.transfer(newBaffles);
-        }
-        Info<< endl;
     }
 
+    // Duplicate points on faceZones of type boundary
+    meshRefiner_.dupNonManifoldBoundaryPoints();
+
 
     bool doFeatures = false;
     label nFeatIter = 1;
@@ -2720,6 +2555,12 @@ void Foam::autoSnapDriver::doSnap
 
     bool meshOk = false;
 
+
+    // Get the labels of added patches.
+    labelList adaptPatchIDs(meshRefiner_.meshedPatches());
+
+
+
     {
         autoPtr<indirectPrimitivePatch> ppPtr
         (
@@ -2732,7 +2573,7 @@ void Foam::autoSnapDriver::doSnap
 
 
         // Distance to attract to nearest feature on surface
-        const scalarField snapDist(calcSnapDistance(mesh, snapParams, ppPtr()));
+        scalarField snapDist(calcSnapDistance(mesh, snapParams, ppPtr()));
 
 
         // Construct iterative mesh mover.
@@ -2774,13 +2615,27 @@ void Foam::autoSnapDriver::doSnap
         Info<< "Checked initial mesh in = "
             << mesh.time().cpuTimeIncrement() << " s\n" << nl << endl;
 
+        // Extract baffles across internal faceZones (for checking mesh quality
+        // across
+        labelPairList internalBaffles
+        (
+            meshRefiner_.subsetBaffles
+            (
+                mesh,
+                internalFaceZones,
+                localPointRegion::findDuplicateFacePairs(mesh)
+            )
+        );
+
+
+
         // Pre-smooth patch vertices (so before determining nearest)
         preSmoothPatch
         (
             meshRefiner_,
             snapParams,
             nInitErrors,
-            baffles,
+            internalBaffles,
             meshMoverPtr()
         );
 
@@ -2793,235 +2648,35 @@ void Foam::autoSnapDriver::doSnap
         List<pointConstraint> patchConstraints;
 
 
+        //- Any faces to split
+        DynamicList<label> splitFaces;
+        //- Indices in face to split across
+        DynamicList<labelPair> splits;
+
+
         for (label iter = 0; iter < nFeatIter; iter++)
         {
-            //if (doFeatures && (iter == 0 || iter == nFeatIter/2))
-            //{
-            //    Info<< "Splitting diagonal attractions" << endl;
-            //
-            //    indirectPrimitivePatch& pp = ppPtr();
-            //    motionSmoother& meshMover = meshMoverPtr();
-            //
-            //    // Calculate displacement at every patch point. Insert into
-            //    // meshMover.
-            //    // Calculate displacement at every patch point
-            //    pointField nearestPoint;
-            //    vectorField nearestNormal;
-            //
-            //    if (snapParams.detectNearSurfacesSnap())
-            //    {
-            //        nearestPoint.setSize(pp.nPoints(), vector::max);
-            //        nearestNormal.setSize(pp.nPoints(), vector::zero);
-            //    }
-            //
-            //    vectorField disp = calcNearestSurface
-            //    (
-            //        meshRefiner_,
-            //        snapDist,
-            //        pp,
-            //        nearestPoint,
-            //        nearestNormal
-            //    );
-            //
-            //
-            //    // Override displacement at thin gaps
-            //    if (snapParams.detectNearSurfacesSnap())
-            //    {
-            //        detectNearSurfaces
-            //        (
-            //            Foam::cos(degToRad(planarAngle)),// planar gaps
-            //            pp,
-            //            nearestPoint,   // surfacepoint from nearest test
-            //            nearestNormal,  // surfacenormal from nearest test
-            //
-            //            disp
-            //        );
-            //    }
-            //
-            //    // Override displacement with feature edge attempt
-            //    const label iter = 0;
-            //    calcNearestSurfaceFeature
-            //    (
-            //        snapParams,
-            //        false,   // avoidSnapProblems
-            //        iter,
-            //        featureCos,
-            //        scalar(iter+1)/nFeatIter,
-            //        snapDist,
-            //        disp,
-            //        meshMover,
-            //        patchAttraction,
-            //        patchConstraints
-            //    );
-            //
-            //
-            //    const labelList& bFaces = ppPtr().addressing();
-            //    DynamicList<label> splitFaces(bFaces.size());
-            //    DynamicList<labelPair> splits(bFaces.size());
-            //
-            //    forAll(bFaces, faceI)
-            //    {
-            //        const labelPair split
-            //        (
-            //            findDiagonalAttraction
-            //            (
-            //                ppPtr(),
-            //                patchAttraction,
-            //                patchConstraints,
-            //                faceI
-            //            )
-            //        );
-            //
-            //        if (split != labelPair(-1, -1))
-            //        {
-            //            splitFaces.append(bFaces[faceI]);
-            //            splits.append(split);
-            //        }
-            //    }
-            //
-            //    Info<< "Splitting "
-            //        << returnReduce(splitFaces.size(), sumOp<label>())
-            //        << " faces along diagonal attractions" << endl;
-            //
-            //    autoPtr<mapPolyMesh> mapPtr = meshRefiner_.splitFaces
-            //    (
-            //        splitFaces,
-            //        splits
-            //    );
-            //
-            //    const labelList& faceMap = mapPtr().faceMap();
-            //    meshRefinement::updateList(faceMap, -1, duplicateFace);
-            //    const labelList& reverseFaceMap = mapPtr().reverseFaceMap();
-            //    forAll(baffles, i)
-            //    {
-            //        labelPair& baffle = baffles[i];
-            //        baffle.first() = reverseFaceMap[baffle.first()];
-            //        baffle.second() = reverseFaceMap[baffle.second()];
-            //    }
-            //
-            //    meshMoverPtr.clear();
-            //    ppPtr.clear();
-            //
-            //    ppPtr = meshRefinement::makePatch(mesh, adaptPatchIDs);
-            //    meshMoverPtr.reset
-            //    (
-            //        new motionSmoother
-            //        (
-            //            mesh,
-            //            ppPtr(),
-            //            adaptPatchIDs,
-            //            meshRefinement::makeDisplacementField
-            //            (
-            //                pointMesh::New(mesh),
-            //                adaptPatchIDs
-            //            ),
-            //            motionDict
-            //        )
-            //    );
-            //
-            //    if (debug&meshRefinement::MESH)
-            //    {
-            //        const_cast<Time&>(mesh.time())++;
-            //        Info<< "Writing split diagonal mesh to time "
-            //            << meshRefiner_.timeName() << endl;
-            //        meshRefiner_.write
-            //        (
-            //            meshRefinement::debugType(debug),
-            //            meshRefinement::writeType
-            //            (
-            //                meshRefinement::writeLevel()
-            //              | meshRefinement::WRITEMESH
-            //            ),
-            //            mesh.time().path()/meshRefiner_.timeName()
-            //        );
-            //    }
-            //}
-            //else
-            //if
-            //(
-            //    doFeatures
-            // && (iter == 1 || iter == nFeatIter/2+1 || iter == nFeatIter-1)
-            //)
-            //{
-            //    Info<< "Splitting warped faces" << endl;
-            //
-            //    const labelList& bFaces = ppPtr().addressing();
-            //    DynamicList<label> splitFaces(bFaces.size());
-            //    DynamicList<labelPair> splits(bFaces.size());
-            //
-            //    detectWarpedFaces
-            //    (
-            //        featureCos,
-            //        ppPtr(),
-            //
-            //        splitFaces,
-            //        splits
-            //    );
-            //
-            //    Info<< "Splitting "
-            //        << returnReduce(splitFaces.size(), sumOp<label>())
-            //        << " faces along diagonal to avoid warpage" << endl;
-            //
-            //    autoPtr<mapPolyMesh> mapPtr = meshRefiner_.splitFaces
-            //    (
-            //        splitFaces,
-            //        splits
-            //    );
-            //
-            //    const labelList& faceMap = mapPtr().faceMap();
-            //    meshRefinement::updateList(faceMap, -1, duplicateFace);
-            //    const labelList& reverseFaceMap = mapPtr().reverseFaceMap();
-            //    forAll(baffles, i)
-            //    {
-            //        labelPair& baffle = baffles[i];
-            //        baffle.first() = reverseFaceMap[baffle.first()];
-            //        baffle.second() = reverseFaceMap[baffle.second()];
-            //    }
-            //
-            //    meshMoverPtr.clear();
-            //    ppPtr.clear();
-            //
-            //    ppPtr = meshRefinement::makePatch(mesh, adaptPatchIDs);
-            //    meshMoverPtr.reset
-            //    (
-            //        new motionSmoother
-            //        (
-            //            mesh,
-            //            ppPtr(),
-            //            adaptPatchIDs,
-            //            meshRefinement::makeDisplacementField
-            //            (
-            //                pointMesh::New(mesh),
-            //                adaptPatchIDs
-            //            ),
-            //            motionDict
-            //        )
-            //    );
-            //
-            //    if (debug&meshRefinement::MESH)
-            //    {
-            //        const_cast<Time&>(mesh.time())++;
-            //        Info<< "Writing split warped mesh to time "
-            //            << meshRefiner_.timeName() << endl;
-            //        meshRefiner_.write
-            //        (
-            //            meshRefinement::debugType(debug),
-            //            meshRefinement::writeType
-            //            (
-            //                meshRefinement::writeLevel()
-            //              | meshRefinement::WRITEMESH
-            //            ),
-            //            mesh.time().path()/meshRefiner_.timeName()
-            //        );
-            //    }
-            //}
-
-
-
             Info<< nl
                 << "Morph iteration " << iter << nl
                 << "-----------------" << endl;
 
+            // Splitting iteration?
+            bool doSplit = false;
+            if
+            (
+                doFeatures
+             && snapParams.nFaceSplitInterval() > 0
+             && (
+                    (iter == nFeatIter-1)
+                 || (iter > 0 && (iter%snapParams.nFaceSplitInterval()) == 0)
+                )
+            )
+            {
+                doSplit = true;
+            }
+
+
+
             indirectPrimitivePatch& pp = ppPtr();
             motionSmoother& meshMover = meshMoverPtr();
 
@@ -3065,18 +2720,26 @@ void Foam::autoSnapDriver::doSnap
             // Override displacement with feature edge attempt
             if (doFeatures)
             {
+                splitFaces.clear();
+                splits.clear();
                 disp = calcNearestSurfaceFeature
                 (
                     snapParams,
-                    true,   // avoidSnapProblems
+                    !doSplit,       // alignMeshEdges
                     iter,
                     featureCos,
                     scalar(iter+1)/nFeatIter,
+
                     snapDist,
                     disp,
+                    nearestNormal,
                     meshMover,
+
                     patchAttraction,
-                    patchConstraints
+                    patchConstraints,
+
+                    splitFaces,
+                    splits
                 );
             }
 
@@ -3108,7 +2771,7 @@ void Foam::autoSnapDriver::doSnap
             (
                 snapParams,
                 nInitErrors,
-                baffles,
+                internalBaffles,
                 meshMover
             );
 
@@ -3148,66 +2811,190 @@ void Foam::autoSnapDriver::doSnap
 
             // Use current mesh as base mesh
             meshMover.correct();
+
+
+
+            // See if any faces need splitting
+            label nTotalSplit = returnReduce(splitFaces.size(), sumOp<label>());
+            if (nTotalSplit && doSplit)
+            {
+                // Filter out baffle faces from faceZones of type
+                // internal/baffle
+
+                labelList duplicateFace(getInternalOrBaffleDuplicateFace());
+
+                {
+                    labelList oldSplitFaces(splitFaces.xfer());
+                    List<labelPair> oldSplits(splits.xfer());
+                    forAll(oldSplitFaces, i)
+                    {
+                        if (duplicateFace[oldSplitFaces[i]] == -1)
+                        {
+                            splitFaces.append(oldSplitFaces[i]);
+                            splits.append(oldSplits[i]);
+                        }
+                    }
+                    nTotalSplit = returnReduce
+                    (
+                        splitFaces.size(),
+                        sumOp<label>()
+                    );
+                }
+
+                // Update mesh
+                meshRefiner_.splitFacesUndo
+                (
+                    splitFaces,
+                    splits,
+                    motionDict,
+
+                    duplicateFace,
+                    internalBaffles
+                );
+
+                // Redo meshMover
+                meshMoverPtr.clear();
+                ppPtr.clear();
+
+                // Update mesh mover
+                ppPtr = meshRefinement::makePatch(mesh, adaptPatchIDs);
+                meshMoverPtr.reset
+                (
+                    new motionSmoother
+                    (
+                        mesh,
+                        ppPtr(),
+                        adaptPatchIDs,
+                        meshRefinement::makeDisplacementField
+                        (
+                            pointMesh::New(mesh),
+                            adaptPatchIDs
+                        ),
+                        motionDict
+                    )
+                );
+
+                // Update snapping distance
+                snapDist = calcSnapDistance(mesh, snapParams, ppPtr());
+
+
+                if (debug&meshRefinement::MESH)
+                {
+                    const_cast<Time&>(mesh.time())++;
+                    Info<< "Writing split-faces mesh to time "
+                        << meshRefiner_.timeName() << endl;
+                    meshRefiner_.write
+                    (
+                        meshRefinement::debugType(debug),
+                        meshRefinement::writeType
+                        (
+                            meshRefinement::writeLevel()
+                          | meshRefinement::WRITEMESH
+                        ),
+                        mesh.time().path()/meshRefiner_.timeName()
+                    );
+                }
+            }
+
+
+            if (debug&meshRefinement::MESH)
+            {
+                forAll(internalBaffles, i)
+                {
+                    const labelPair& p = internalBaffles[i];
+                    const point& fc0 = mesh.faceCentres()[p[0]];
+                    const point& fc1 = mesh.faceCentres()[p[1]];
+
+                    if (mag(fc0-fc1) > meshRefiner_.mergeDistance())
+                    {
+                        FatalErrorIn("autoSnapDriver::doSnap(..)")
+                            << "Separated baffles : f0:" << p[0]
+                            << " centre:" << fc0
+                            << " f1:" << p[1] << " centre:" << fc1
+                            << " distance:" << mag(fc0-fc1)
+                            << exit(FatalError);
+                    }
+                }
+            }
         }
     }
 
 
     // Merge any introduced baffles (from faceZones of faceType 'internal')
     {
-        autoPtr<mapPolyMesh> mapPtr = mergeZoneBaffles(baffles);
+        autoPtr<mapPolyMesh> mapPtr = meshRefiner_.mergeZoneBaffles
+        (
+            true,   // internal zones
+            false   // baffle zones
+        );
 
         if (mapPtr.valid())
         {
-            forAll(duplicateFace, faceI)
+            if (debug & meshRefinement::MESH)
             {
-                if (duplicateFace[faceI] != -1)
-                {
-                    duplicateFace[faceI] = mapPtr().reverseFaceMap()[faceI];
-                }
+                const_cast<Time&>(mesh.time())++;
+                Info<< "Writing baffle-merged mesh to time "
+                    << meshRefiner_.timeName() << endl;
+                meshRefiner_.write
+                (
+                    meshRefinement::debugType(debug),
+                    meshRefinement::writeType
+                    (
+                        meshRefinement::writeLevel()
+                      | meshRefinement::WRITEMESH
+                    ),
+                    meshRefiner_.timeName()
+                );
             }
         }
     }
 
     // Repatch faces according to nearest. Do not repatch baffle faces.
     {
-        autoPtr<mapPolyMesh> mapPtr = repatchToSurface
-        (
-            snapParams,
-            adaptPatchIDs,
-            duplicateFace
-        );
-        meshRefinement::updateList(mapPtr().faceMap(), -1, duplicateFace);
+        labelList duplicateFace(getInternalOrBaffleDuplicateFace());
+
+        repatchToSurface(snapParams, adaptPatchIDs, duplicateFace);
     }
 
-    // Repatching might have caused faces to be on same patch and hence
-    // mergeable so try again to merge coplanar faces. Do not merge baffle
-    // faces to ensure they both stay the same.
-    label nChanged = meshRefiner_.mergePatchFacesUndo
-    (
-        featureCos,     // minCos
-        featureCos,     // concaveCos
-        meshRefiner_.meshedPatches(),
-        motionDict,
-        duplicateFace   // faces not to merge
-    );
+    if (mergePatchFaces)
+    {
+        labelList duplicateFace(getInternalOrBaffleDuplicateFace());
 
-    nChanged += meshRefiner_.mergeEdgesUndo(featureCos, motionDict);
+        // Repatching might have caused faces to be on same patch and hence
+        // mergeable so try again to merge coplanar faces. Do not merge baffle
+        // faces to ensure they both stay the same.
+        label nChanged = meshRefiner_.mergePatchFacesUndo
+        (
+            featureCos,     // minCos
+            featureCos,     // concaveCos
+            meshRefiner_.meshedPatches(),
+            motionDict,
+            duplicateFace   // faces not to merge
+        );
 
-    if (nChanged > 0 && debug & meshRefinement::MESH)
+        nChanged += meshRefiner_.mergeEdgesUndo(featureCos, motionDict);
+
+        if (nChanged > 0 && debug & meshRefinement::MESH)
+        {
+            const_cast<Time&>(mesh.time())++;
+            Info<< "Writing patchFace merged mesh to time "
+                << meshRefiner_.timeName() << endl;
+            meshRefiner_.write
+            (
+                meshRefinement::debugType(debug),
+                meshRefinement::writeType
+                (
+                    meshRefinement::writeLevel()
+                  | meshRefinement::WRITEMESH
+                ),
+                meshRefiner_.timeName()
+            );
+        }
+    }
+
+    if (debug & meshRefinement::MESH)
     {
         const_cast<Time&>(mesh.time())++;
-        Info<< "Writing patchFace merged mesh to time "
-            << meshRefiner_.timeName() << endl;
-        meshRefiner_.write
-        (
-            meshRefinement::debugType(debug),
-            meshRefinement::writeType
-            (
-                meshRefinement::writeLevel()
-              | meshRefinement::WRITEMESH
-            ),
-            meshRefiner_.timeName()
-        );
     }
 }
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
index b72d147a84..e8a79eb704 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.H
@@ -37,6 +37,7 @@ SourceFiles
 #define autoSnapDriver_H
 
 #include "meshRefinement.H"
+#include "DynamicField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -45,6 +46,7 @@ namespace Foam
 
 // Forward declaration of classes
 class motionSmoother;
+class refinementParameters;
 class snapParameters;
 class pointConstraint;
 
@@ -87,18 +89,18 @@ class autoSnapDriver
                 const List<labelPair>&
             );
 
-            //static tmp<pointField> avg
-            //(
-            //    const indirectPrimitivePatch&,
-            //    const pointField&
-            //);
+            static tmp<pointField> avg
+            (
+                const indirectPrimitivePatch&,
+                const pointField&
+            );
 
             //- Calculate displacement per patch point. Wip.
-            //static tmp<pointField> smoothLambdaMuPatchDisplacement
-            //(
-            //    const motionSmoother& meshMover,
-            //    const List<labelPair>& baffles
-            //);
+            static pointField smoothLambdaMuPatchDisplacement
+            (
+                const motionSmoother& meshMover,
+                const List<labelPair>& baffles
+            );
 
 
             //- Check that face zones are synced
@@ -136,6 +138,10 @@ class autoSnapDriver
                 DynamicList<labelPair>& splits
             ) const;
 
+            //- Get per face -1 or label of opposite face if on internal/baffle
+            //  faceZone
+            labelList getInternalOrBaffleDuplicateFace() const;
+
             // Feature line snapping
 
                 //- Is point on two feature edges that make a largish angle?
@@ -177,8 +183,8 @@ class autoSnapDriver
                     const scalarField& faceSnapDist,
                     vectorField& faceDisp,
                     vectorField& faceSurfaceNormal,
-                    labelList& faceSurfaceRegion,
-                    vectorField& faceRotation
+                    labelList& faceSurfaceRegion
+                    //vectorField& faceRotation
                 ) const;
                 void calcNearestFacePointProperties
                 (
@@ -253,6 +259,86 @@ class autoSnapDriver
                     const label faceI
                 ) const;
 
+                scalar pyrVol
+                (
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& featureAttraction,
+                    const face& localF,
+                    const point& cc
+                ) const;
+                void facePoints
+                (
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& featureAttraction,
+                    const vectorField& nearestAttraction,
+                    const face& f,
+                    DynamicField<point>& points
+                ) const;
+                scalar pyrVol
+                (
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& featureAttraction,
+                    const vectorField& nearestAttraction,
+                    const face& localF,
+                    const point& cc
+                ) const;
+                Tuple2<point, vector> centreAndNormal
+                (
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& featureAttraction,
+                    const vectorField& nearestAttraction,
+                    const face& localF
+                ) const;
+                bool isSplitAlignedWithFeature
+                (
+                    const scalar featureCos,
+                    const point& newPt0,
+                    const pointConstraint& pc0,
+                    const point& newPt1,
+                    const pointConstraint& pc1
+                ) const;
+                bool isConcave
+                (
+                    const point& c0,
+                    const vector& area0,
+                    const point& c1,
+                    const vector& area1,
+                    const scalar concaveCos
+                ) const;
+                labelPair findDiagonalAttraction
+                (
+                    const scalar featureCos,
+                    const scalar concaveCos,
+                    const scalar minAreaFraction,
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& patchAttraction,
+                    const List<pointConstraint>& patchConstraints,
+                    const vectorField& nearestAttraction,
+                    const vectorField& nearestNormal,
+                    const label faceI,
+
+                    DynamicField<point>& points0,
+                    DynamicField<point>& points1
+                ) const;
+
+                //- Do all logic on whether to add face cut to diagonal
+                //  attraction
+                void splitDiagonals
+                (
+                    const scalar featureCos,
+                    const scalar concaveCos,
+                    const scalar minAreaFraction,
+
+                    const indirectPrimitivePatch& pp,
+                    const vectorField& nearestAttraction,
+                    const vectorField& nearestNormal,
+
+                    vectorField& patchAttraction,
+                    List<pointConstraint>& patchConstraints,
+                    DynamicList<label>& splitFaces,
+                    DynamicList<labelPair>& splits
+                ) const;
+
                 //- Avoid attraction across face diagonal since would
                 //  cause face squeeze
                 void avoidDiagonalAttraction
@@ -264,6 +350,14 @@ class autoSnapDriver
                     List<pointConstraint>& patchConstraints
                 ) const;
 
+                //- Write some stats about constraints
+                void writeStats
+                (
+                    const indirectPrimitivePatch& pp,
+                    const PackedBoolList& isMasterPoint,
+                    const List<pointConstraint>& patchConstraints
+                ) const;
+
                 //- Return hit if on multiple points
                 pointIndexHit findMultiPatchPoint
                 (
@@ -320,7 +414,6 @@ class autoSnapDriver
                 void featureAttractionUsingReconstruction
                 (
                     const label iter,
-                    const bool avoidSnapProblems,
                     const scalar featureCos,
                     const indirectPrimitivePatch& pp,
                     const scalarField& snapDist,
@@ -450,12 +543,19 @@ class autoSnapDriver
                 void featureAttractionUsingFeatureEdges
                 (
                     const label iter,
-                    const bool avoidSnapProblems,
-                    const scalar featureCos,
                     const bool multiRegionFeatureSnap,
+
+                    const bool detectBaffles,
+                    const bool releasePoints,
+                    const bool stringFeatures,
+                    const bool avoidDiagonal,
+
+                    const scalar featureCos,
+
                     const indirectPrimitivePatch& pp,
                     const scalarField& snapDist,
                     const vectorField& nearestDisp,
+                    const vectorField& nearestNormal,
 
                     const List<List<point> >& pointFaceSurfNormals,
                     const List<List<point> >& pointFaceDisp,
@@ -465,12 +565,14 @@ class autoSnapDriver
                     vectorField& patchAttraction,
                     List<pointConstraint>& patchConstraints
                 ) const;
+
                 void preventFaceSqueeze
                 (
                     const label iter,
                     const scalar featureCos,
                     const indirectPrimitivePatch& pp,
                     const scalarField& snapDist,
+                    const vectorField& nearestAttraction,
 
                     vectorField& patchAttraction,
                     List<pointConstraint>& patchConstraints
@@ -483,15 +585,19 @@ class autoSnapDriver
                 vectorField calcNearestSurfaceFeature
                 (
                     const snapParameters& snapParams,
-                    const bool avoidSnapProblems,
+                    const bool alignMeshEdges,
                     const label iter,
                     const scalar featureCos,
                     const scalar featureAttract,
                     const scalarField& snapDist,
                     const vectorField& nearestDisp,
+                    const vectorField& nearestNormal,
                     motionSmoother& meshMover,
                     vectorField& patchAttraction,
-                    List<pointConstraint>& patchConstraints
+                    List<pointConstraint>& patchConstraints,
+
+                    DynamicList<label>& splitFaces,
+                    DynamicList<labelPair>& splits
                 ) const;
 
 
@@ -622,6 +728,7 @@ public:
             (
                 const dictionary& snapDict,
                 const dictionary& motionDict,
+                const bool mergePatchFaces,
                 const scalar featureCos,
                 const scalar planarAngle,
                 const snapParameters& snapParams
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C
index c7a00df00e..256780cfd6 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C
@@ -38,6 +38,7 @@ License
 #include "indexedOctree.H"
 #include "snapParameters.H"
 #include "PatchTools.H"
+#include "pyramidPointFaceRef.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -222,8 +223,8 @@ void Foam::autoSnapDriver::calcNearestFace
     const scalarField& faceSnapDist,
     vectorField& faceDisp,
     vectorField& faceSurfaceNormal,
-    labelList& faceSurfaceGlobalRegion,
-    vectorField& faceRotation
+    labelList& faceSurfaceGlobalRegion
+    //vectorField& faceRotation
 ) const
 {
     const fvMesh& mesh = meshRefiner_.mesh();
@@ -407,38 +408,38 @@ void Foam::autoSnapDriver::calcNearestFace
     }
 
 
-    // Determine rotation
-    // ~~~~~~~~~~~~~~~~~~
-
-    // Determine rotation axis
-    faceRotation.setSize(pp.size());
-    faceRotation = vector::zero;
-
-    forAll(faceRotation, faceI)
-    {
-        // Note: extend to >180 degrees checking
-        faceRotation[faceI] =
-            pp.faceNormals()[faceI]
-          ^ faceSurfaceNormal[faceI];
-    }
-
-    if (debug&meshRefinement::ATTRACTION)
-    {
-        dumpMove
-        (
-            mesh.time().path()
-          / "faceDisp_" + name(iter) + ".obj",
-            pp.faceCentres(),
-            pp.faceCentres() + faceDisp
-        );
-        dumpMove
-        (
-            mesh.time().path()
-          / "faceRotation_" + name(iter) + ".obj",
-            pp.faceCentres(),
-            pp.faceCentres() + faceRotation
-        );
-    }
+    //// Determine rotation
+    //// ~~~~~~~~~~~~~~~~~~
+    //
+    //// Determine rotation axis
+    //faceRotation.setSize(pp.size());
+    //faceRotation = vector::zero;
+    //
+    //forAll(faceRotation, faceI)
+    //{
+    //    // Note: extend to >180 degrees checking
+    //    faceRotation[faceI] =
+    //        pp.faceNormals()[faceI]
+    //      ^ faceSurfaceNormal[faceI];
+    //}
+    //
+    //if (debug&meshRefinement::ATTRACTION)
+    //{
+    //    dumpMove
+    //    (
+    //        mesh.time().path()
+    //      / "faceDisp_" + name(iter) + ".obj",
+    //        pp.faceCentres(),
+    //        pp.faceCentres() + faceDisp
+    //    );
+    //    dumpMove
+    //    (
+    //        mesh.time().path()
+    //      / "faceRotation_" + name(iter) + ".obj",
+    //        pp.faceCentres(),
+    //        pp.faceCentres() + faceRotation
+    //    );
+    //}
 }
 
 
@@ -823,6 +824,56 @@ Foam::pointIndexHit Foam::autoSnapDriver::findMultiPatchPoint
 }
 
 
+void Foam::autoSnapDriver::writeStats
+(
+    const indirectPrimitivePatch& pp,
+    const PackedBoolList& isMasterPoint,
+    const List<pointConstraint>& patchConstraints
+) const
+{
+    const labelList& meshPoints = pp.meshPoints();
+
+    label nMasterPoints = 0;
+    label nPlanar = 0;
+    label nEdge = 0;
+    label nPoint = 0;
+
+    forAll(patchConstraints, pointI)
+    {
+        if (isMasterPoint[meshPoints[pointI]])
+        {
+            nMasterPoints++;
+
+            if (patchConstraints[pointI].first() == 1)
+            {
+                nPlanar++;
+            }
+            else if (patchConstraints[pointI].first() == 2)
+            {
+                nEdge++;
+            }
+            else if (patchConstraints[pointI].first() == 3)
+            {
+                nPoint++;
+            }
+        }
+    }
+
+    reduce(nMasterPoints, sumOp<label>());
+    reduce(nPlanar, sumOp<label>());
+    reduce(nEdge, sumOp<label>());
+    reduce(nPoint, sumOp<label>());
+    Info<< "total master points :" << nMasterPoints
+        << " of which attracted to :" << nl
+        << "    feature point   : " << nPoint << nl
+        << "    feature edge    : " << nEdge << nl
+        << "    nearest surface : " << nPlanar << nl
+        << "    rest            : " << nMasterPoints-nPoint-nEdge-nPlanar
+        << nl
+        << endl;
+}
+
+
 void Foam::autoSnapDriver::featureAttractionUsingReconstruction
 (
     const label iter,
@@ -1019,7 +1070,6 @@ void Foam::autoSnapDriver::featureAttractionUsingReconstruction
 void Foam::autoSnapDriver::featureAttractionUsingReconstruction
 (
     const label iter,
-    const bool avoidSnapProblems,
     const scalar featureCos,
 
     const indirectPrimitivePatch& pp,
@@ -1443,7 +1493,6 @@ void Foam::autoSnapDriver::releasePointsNextToMultiPatch
 }
 
 
-// If only two attractions and across face return the face indices
 Foam::labelPair Foam::autoSnapDriver::findDiagonalAttraction
 (
     const indirectPrimitivePatch& pp,
@@ -1460,53 +1509,427 @@ Foam::labelPair Foam::autoSnapDriver::findDiagonalAttraction
 
     if (f.size() >= 4)
     {
-        forAll(f, fp)
+        for (label startFp = 0; startFp < f.size()-2; startFp++)
         {
-            label pointI = f[fp];
-            if (patchConstraints[pointI].first() >= 2)
+            label minFp = f.rcIndex(startFp);
+
+            for
+            (
+                label endFp = f.fcIndex(f.fcIndex(startFp));
+                endFp < f.size() && endFp != minFp;
+                endFp++
+            )
             {
-                // Attract to feature edge or point
-                if (attractIndices[0] == -1)
+                if
+                (
+                    patchConstraints[f[startFp]].first() >= 2
+                 && patchConstraints[f[endFp]].first() >= 2
+                )
                 {
-                    // First attraction. Store
-                    attractIndices[0] = fp;
-                }
-                else if (attractIndices[1] == -1)
-                {
-                    // Second attraction. Check if not consecutive to first
-                    // attraction
-                    label fp0 = attractIndices[0];
-                    if (f.fcIndex(fp0) == fp || f.fcIndex(fp) == fp0)
-                    {
-                        // Consecutive. Skip.
-                        attractIndices = labelPair(-1, -1);
-                        break;
-                    }
-                    else
-                    {
-                        attractIndices[1] = fp;
-                    }
-                }
-                else
-                {
-                    // More than two attractions. Skip.
-                    attractIndices = labelPair(-1, -1);
+                    attractIndices = labelPair(startFp, endFp);
                     break;
                 }
             }
         }
+    }
+    return attractIndices;
+}
 
 
-        if (attractIndices[1] == -1)
+bool Foam::autoSnapDriver::isSplitAlignedWithFeature
+(
+    const scalar featureCos,
+    const point& p0,
+    const pointConstraint& pc0,
+    const point& p1,
+    const pointConstraint& pc1
+) const
+{
+    vector d(p1-p0);
+    scalar magD = mag(d);
+    if (magD < VSMALL)
+    {
+        // Two diagonal points already colocated?
+        return false;
+    }
+    else
+    {
+        d /= magD;
+
+        // Is diagonal d aligned with at least one of the feature
+        // edges?
+
+        if (pc0.first() == 2 && mag(d & pc0.second()) > featureCos)
         {
-            // Found only one attraction. Skip.
-            attractIndices = labelPair(-1, -1);
+            return true;
+        }
+        else if (pc1.first() == 2 && mag(d & pc1.second()) > featureCos)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+
+// Is situation very concave
+bool Foam::autoSnapDriver::isConcave
+(
+    const point& c0,
+    const vector& area0,
+    const point& c1,
+    const vector& area1,
+    const scalar concaveCos
+) const
+{
+    vector n0 = area0;
+    scalar magN0 = mag(n0);
+    if (magN0 < VSMALL)
+    {
+        // Zero area face. What to return? For now disable splitting.
+        return true;
+    }
+    n0 /= magN0;
+
+    // Distance from c1 to plane of face0
+    scalar d = (c1-c0)&n0;
+
+    if (d <= 0)
+    {
+        // Convex (face1 centre on 'inside' of face0)
+        return false;
+    }
+    else
+    {
+        // Is a bit or very concave?
+        vector n1 = area1;
+        scalar magN1 = mag(n1);
+        if (magN1 < VSMALL)
+        {
+            // Zero area face. See above
+            return true;
+        }
+        n1 /= magN1;
+
+        if ((n0&n1) < concaveCos)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+
+Foam::labelPair Foam::autoSnapDriver::findDiagonalAttraction
+(
+    const scalar featureCos,
+    const scalar concaveCos,
+    const scalar minAreaRatio,
+    const indirectPrimitivePatch& pp,
+    const vectorField& patchAttr,
+    const List<pointConstraint>& patchConstraints,
+    const vectorField& nearestAttr,
+    const vectorField& nearestNormal,
+    const label faceI,
+
+    DynamicField<point>& points0,
+    DynamicField<point>& points1
+) const
+{
+    const face& localF = pp.localFaces()[faceI];
+
+    labelPair attractIndices(-1, -1);
+
+    if (localF.size() >= 4)
+    {
+        const pointField& localPts = pp.localPoints();
+
+        //// Estimate cell centre taking patchAttraction into account
+        //// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        //// (is this necessary?)
+        //const polyMesh& mesh = meshRefiner_.mesh();
+        //label meshFaceI = pp.addressing()[faceI];
+        //const face& meshF = mesh.faces()[meshFaceI];
+        //label cellI = mesh.faceOwner()[meshFaceI];
+        //const labelList& cPoints = mesh.cellPoints(cellI);
+        //
+        //point cc(mesh.points()[meshF[0]]);
+        //for (label i = 1; i < meshF.size(); i++)
+        //{
+        //    cc += mesh.points()[meshF[i]]+patchAttr[localF[i]];
+        //}
+        //forAll(cPoints, i)
+        //{
+        //    label pointI = cPoints[i];
+        //    if (findIndex(meshF, pointI) == -1)
+        //    {
+        //        cc += mesh.points()[pointI];
+        //    }
+        //}
+        //cc /= cPoints.size();
+        ////const point& cc = mesh.cellCentres()[cellI];
+        //
+        //const scalar vol = pyrVol(pp, patchAttr, localF, cc);
+        //const scalar area = localF.mag(localPts);
+
+
+
+        // Try all diagonal cuts
+        // ~~~~~~~~~~~~~~~~~~~~~
+
+        face f0(3);
+        face f1(3);
+
+        for (label startFp = 0; startFp < localF.size()-2; startFp++)
+        {
+            label minFp = localF.rcIndex(startFp);
+
+            for
+            (
+                label endFp = localF.fcIndex(localF.fcIndex(startFp));
+                endFp < localF.size() && endFp != minFp;
+                endFp++
+            )
+            {
+                label startPtI = localF[startFp];
+                label endPtI = localF[endFp];
+
+                const pointConstraint& startPc = patchConstraints[startPtI];
+                const pointConstraint& endPc = patchConstraints[endPtI];
+
+                if (startPc.first() >= 2 && endPc.first() >= 2)
+                {
+                    if (startPc.first() == 2 || endPc.first() == 2)
+                    {
+                        // Check if
+                        // - sameish feature edge normal
+                        // - diagonal aligned with feature edge normal
+                        point start = localPts[startPtI]+patchAttr[startPtI];
+                        point end = localPts[endPtI]+patchAttr[endPtI];
+
+                        if
+                        (
+                           !isSplitAlignedWithFeature
+                            (
+                                featureCos,
+                                start,
+                                startPc,
+                                end,
+                                endPc
+                            )
+                        )
+                        {
+                            // Attract to different features. No need to
+                            // introduce split
+                            continue;
+                        }
+                    }
+
+
+
+                    // Form two faces
+                    // ~~~~~~~~~~~~~~
+                    // Predict position of faces. End points of the faces
+                    // attract to the feature
+                    // and all the other points just attract to the nearest
+
+                    // face0
+
+                    f0.setSize(endFp-startFp+1);
+                    label i0 = 0;
+                    for (label fp = startFp; fp <= endFp; fp++)
+                    {
+                        f0[i0++] = localF[fp];
+                    }
+
+                    // Get compact face and points
+                    const face compact0(identity(f0.size()));
+                    points0.clear();
+                    points0.append(localPts[f0[0]] + patchAttr[f0[0]]);
+                    for (label fp=1; fp < f0.size()-1; fp++)
+                    {
+                        label pI = f0[fp];
+                        points0.append(localPts[pI] + nearestAttr[pI]);
+                    }
+                    points0.append
+                    (
+                        localPts[f0.last()] + patchAttr[f0.last()]
+                    );
+
+
+                    // face1
+
+                    f1.setSize(localF.size()+2-f0.size());
+                    label i1 = 0;
+                    for
+                    (
+                        label fp = endFp;
+                        fp != startFp;
+                        fp = localF.fcIndex(fp)
+                    )
+                    {
+                        f1[i1++] = localF[fp];
+                    }
+                    f1[i1++] = localF[startFp];
+
+
+                    // Get compact face and points
+                    const face compact1(identity(f1.size()));
+                    points1.clear();
+                    points1.append(localPts[f1[0]] + patchAttr[f1[0]]);
+                    for (label fp=1; fp < f1.size()-1; fp++)
+                    {
+                        label pI = f1[fp];
+                        points1.append(localPts[pI] + nearestAttr[pI]);
+                    }
+                    points1.append
+                    (
+                        localPts[f1.last()] + patchAttr[f1.last()]
+                    );
+
+
+
+                    // Avoid splitting concave faces
+                    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+                    if
+                    (
+                        isConcave
+                        (
+                            compact0.centre(points0),
+                            compact0.normal(points0),
+                            compact1.centre(points1),
+                            compact1.normal(points1),
+                            concaveCos
+                        )
+                    )
+                    {
+                        //// Dump to obj
+                        //Pout<< "# f0:" << f0 << endl;
+                        //forAll(p, i)
+                        //{
+                        //    meshTools::writeOBJ(Pout, points0[i]);
+                        //}
+                        //Pout<< "# f1:" << f1 << endl;
+                        //forAll(p, i)
+                        //{
+                        //    meshTools::writeOBJ(Pout, points1[i]);
+                        //}
+                    }
+                    else
+                    {
+                        // Existing areas
+                        const scalar area0 = f0.mag(localPts);
+                        const scalar area1 = f1.mag(localPts);
+
+                        if
+                        (
+                            area0/area1 >= minAreaRatio
+                         && area1/area0 >= minAreaRatio
+                        )
+                        {
+                            attractIndices = labelPair(startFp, endFp);
+                        }
+                    }
+                }
+            }
         }
     }
     return attractIndices;
 }
 
 
+void Foam::autoSnapDriver::splitDiagonals
+(
+    const scalar featureCos,
+    const scalar concaveCos,
+    const scalar minAreaRatio,
+
+    const indirectPrimitivePatch& pp,
+    const vectorField& nearestAttraction,
+    const vectorField& nearestNormal,
+
+    vectorField& patchAttraction,
+    List<pointConstraint>& patchConstraints,
+    DynamicList<label>& splitFaces,
+    DynamicList<labelPair>& splits
+) const
+{
+    const labelList& bFaces = pp.addressing();
+
+    splitFaces.clear();
+    splitFaces.setCapacity(bFaces.size());
+    splits.clear();
+    splits.setCapacity(bFaces.size());
+
+
+    // Work arrays for storing points of face
+    DynamicField<point> facePoints0;
+    DynamicField<point> facePoints1;
+
+    forAll(bFaces, faceI)
+    {
+        const labelPair split
+        (
+            findDiagonalAttraction
+            (
+                featureCos,
+                concaveCos,
+                minAreaRatio,
+
+                pp,
+                patchAttraction,
+                patchConstraints,
+
+                nearestAttraction,
+                nearestNormal,
+                faceI,
+
+                facePoints0,
+                facePoints1
+            )
+        );
+
+        if (split != labelPair(-1, -1))
+        {
+            splitFaces.append(bFaces[faceI]);
+            splits.append(split);
+
+            const face& f = pp.localFaces()[faceI];
+
+            // Knock out other attractions on face
+            forAll(f, fp)
+            {
+                // Knock out any other constraints
+                if
+                (
+                    fp != split[0]
+                 && fp != split[1]
+                 && patchConstraints[f[fp]].first() >= 2
+                )
+                {
+                    patchConstraints[f[fp]] = pointConstraint
+                    (
+                        Tuple2<label, vector>
+                        (
+                            1,
+                            nearestNormal[f[fp]]
+                        )
+                    );
+                    patchAttraction[f[fp]] = nearestAttraction[f[fp]];
+                }
+            }
+        }
+    }
+}
+
+
 void Foam::autoSnapDriver::avoidDiagonalAttraction
 (
     const label iter,
@@ -1556,7 +1979,8 @@ void Foam::autoSnapDriver::avoidDiagonalAttraction
 
             if (cosAngle > featureCos)
             {
-                // Add the nearest of the other two points as
+                // The two feature edges are roughly in the same direction.
+                // Add the nearest of the other points in the face as
                 // attractor
                 label minFp = -1;
                 scalar minDistSqr = GREAT;
@@ -2258,8 +2682,8 @@ void Foam::autoSnapDriver::determineBaffleFeatures
 
     // Detect baffle edges. Assume initial mesh will have 0,90 or 180
     // (baffle) degree angles so smoothing should make 0,90
-    // to be less than 90.
-    const scalar baffleFeatureCos = Foam::cos(degToRad(91));
+    // to be less than 90. Choose reasonable value
+    const scalar baffleFeatureCos = Foam::cos(degToRad(110));
 
 
     autoPtr<OBJstream> baffleEdgeStr;
@@ -2518,7 +2942,8 @@ void Foam::autoSnapDriver::reverseAttractMeshPoints
         }
 
         Info<< "Initially selected " << returnReduce(nFeats, sumOp<label>())
-            << " points out of " << returnReduce(pp.nPoints(), sumOp<label>())
+            << " mesh points out of "
+            << returnReduce(pp.nPoints(), sumOp<label>())
             << " for reverse attraction." << endl;
 
         // Make sure is synchronised (note: check if constraint is already
@@ -2578,7 +3003,8 @@ void Foam::autoSnapDriver::reverseAttractMeshPoints
 
         Info<< "Selected "
             << returnReduce(attractPoints.size(), sumOp<label>())
-            << " points out of " << returnReduce(pp.nPoints(), sumOp<label>())
+            << " mesh points out of "
+            << returnReduce(pp.nPoints(), sumOp<label>())
             << " for reverse attraction." << endl;
     }
 
@@ -2724,13 +3150,19 @@ void Foam::autoSnapDriver::reverseAttractMeshPoints
 void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
 (
     const label iter,
-    const bool avoidSnapProblems,
-    const scalar featureCos,
     const bool multiRegionFeatureSnap,
 
+    const bool detectBaffles,
+    const bool releasePoints,
+    const bool stringFeatures,
+    const bool avoidDiagonal,
+
+    const scalar featureCos,
+
     const indirectPrimitivePatch& pp,
     const scalarField& snapDist,
     const vectorField& nearestDisp,
+    const vectorField& nearestNormal,
 
     const List<List<point> >& pointFaceSurfNormals,
     const List<List<point> >& pointFaceDisp,
@@ -2802,7 +3234,14 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
         rawPatchConstraints
     );
 
-
+    // Print a bit about the attraction from patch point to feature
+    if (debug)
+    {
+        const polyMesh& mesh = meshRefiner_.mesh();
+        const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
+        Info<< "Raw geometric feature analysis : ";
+        writeStats(pp, isMasterPoint, rawPatchConstraints);
+    }
 
     // Baffle handling
     // ~~~~~~~~~~~~~~~
@@ -2815,25 +3254,36 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
     // detected anything. So explicitly pick up feature edges on the pp
     // (after duplicating points & smoothing so will already have been
     // expanded) and match these to the features.
-    determineBaffleFeatures
-    (
-        iter,
-        featureCos,
+    if (detectBaffles)
+    {
+        determineBaffleFeatures
+        (
+            iter,
+            featureCos,
 
-        pp,
-        snapDist,
+            pp,
+            snapDist,
 
-        // Feature-point to pp point
-        pointAttractor,
-        pointConstraints,
-        // Feature-edge to pp point
-        edgeAttractors,
-        edgeConstraints,
-        // pp point to nearest feature
-        rawPatchAttraction,
-        rawPatchConstraints
-    );
+            // Feature-point to pp point
+            pointAttractor,
+            pointConstraints,
+            // Feature-edge to pp point
+            edgeAttractors,
+            edgeConstraints,
+            // pp point to nearest feature
+            rawPatchAttraction,
+            rawPatchConstraints
+        );
+    }
 
+    // Print a bit about the attraction from patch point to feature
+    if (debug)
+    {
+        const polyMesh& mesh = meshRefiner_.mesh();
+        const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
+        Info<< "After baffle feature analysis : ";
+        writeStats(pp, isMasterPoint, rawPatchConstraints);
+    }
 
 
     // Reverse lookup: Find nearest mesh point to feature edge
@@ -2863,6 +3313,14 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
         patchConstraints
     );
 
+    // Print a bit about the attraction from patch point to feature
+    if (debug)
+    {
+        const polyMesh& mesh = meshRefiner_.mesh();
+        const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
+        Info<< "Reverse attract feature analysis : ";
+        writeStats(pp, isMasterPoint, patchConstraints);
+    }
 
     // Dump
     if (debug&meshRefinement::ATTRACTION)
@@ -2900,38 +3358,38 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
     }
 
 
-    if (avoidSnapProblems)
+    //MEJ: any faces that have multi-patch points only keep the
+    //     multi-patch
+    //     points. The other points on the face will be dragged along
+    //     (hopefully)
+    if (releasePoints)
     {
-        //MEJ: any faces that have multi-patch points only keep the multi-patch
-        //     points. The other points on the face will be dragged along
-        //     (hopefully)
-        if (multiRegionFeatureSnap)
-        {
-            releasePointsNextToMultiPatch
-            (
-                iter,
-                featureCos,
+        releasePointsNextToMultiPatch
+        (
+            iter,
+            featureCos,
 
-                pp,
-                snapDist,
+            pp,
+            snapDist,
 
-                pointFaceCentres,
-                pointFacePatchID,
+            pointFaceCentres,
+            pointFacePatchID,
 
-                rawPatchAttraction,
-                rawPatchConstraints,
+            rawPatchAttraction,
+            rawPatchConstraints,
 
-                patchAttraction,
-                patchConstraints
-            );
-        }
+            patchAttraction,
+            patchConstraints
+        );
+    }
 
 
-        // Snap edges to feature edges
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        // Walk existing edges and snap remaining ones (that are marked as
-        // feature edges in rawPatchConstraints)
-
+    // Snap edges to feature edges
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Walk existing edges and snap remaining ones (that are marked as
+    // feature edges in rawPatchConstraints)
+    if (stringFeatures)
+    {
         stringFeatureEdges
         (
             iter,
@@ -2946,12 +3404,14 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
             patchAttraction,
             patchConstraints
         );
+    }
 
 
-        // Avoid diagonal attraction
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~
-        // Attract one of the non-diagonal points.
-
+    // Avoid diagonal attraction
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Attract one of the non-diagonal points.
+    if (avoidDiagonal)
+    {
         avoidDiagonalAttraction
         (
             iter,
@@ -2962,6 +3422,7 @@ void Foam::autoSnapDriver::featureAttractionUsingFeatureEdges
         );
     }
 
+
     if (debug&meshRefinement::ATTRACTION)
     {
         dumpMove
@@ -2983,11 +3444,27 @@ void Foam::autoSnapDriver::preventFaceSqueeze
 
     const indirectPrimitivePatch& pp,
     const scalarField& snapDist,
+    const vectorField& nearestAttraction,
 
     vectorField& patchAttraction,
     List<pointConstraint>& patchConstraints
 ) const
 {
+    autoPtr<OBJstream> strPtr;
+    if (debug&meshRefinement::ATTRACTION)
+    {
+        strPtr.reset
+        (
+            new OBJstream
+            (
+                meshRefiner_.mesh().time().path()
+              / "faceSqueeze_" + name(iter) + ".obj"
+            )
+        );
+        Info<< "Dumping faceSqueeze corrections to "
+            << strPtr().name() << endl;
+    }
+
     pointField points;
     face singleF;
     forAll(pp.localFaces(), faceI)
@@ -3022,16 +3499,19 @@ void Foam::autoSnapDriver::preventFaceSqueeze
 
         if (nConstraints == f.size())
         {
-            scalar oldArea = f.mag(pp.localPoints());
-            scalar newArea = singleF.mag(points);
-            if (newArea < 0.1*oldArea)
+            if (f.size() == 3)
             {
-                // For now remove the point with largest distance
+                // Triangle: knock out attraction altogether
+
+                // For now keep the points on the longest edge
                 label maxFp = -1;
                 scalar maxS = -1;
                 forAll(f, fp)
                 {
-                    scalar s = magSqr(patchAttraction[f[fp]]);
+                    const point& pt = pp.localPoints()[f[fp]];
+                    const point& nextPt = pp.localPoints()[f.nextLabel(fp)];
+
+                    scalar s = magSqr(pt-nextPt);
                     if (s > maxS)
                     {
                         maxS = s;
@@ -3040,9 +3520,52 @@ void Foam::autoSnapDriver::preventFaceSqueeze
                 }
                 if (maxFp != -1)
                 {
-                    label pointI = f[maxFp];
-                    // Lower attraction on pointI
-                    patchAttraction[pointI] *= 0.5;
+                    label pointI = f.prevLabel(maxFp);
+
+                    // Reset attraction on pointI to nearest
+
+                    const point& pt = pp.localPoints()[pointI];
+
+                    //Pout<< "** on triangle " << pp.faceCentres()[faceI]
+                    //    << " knocking out attraction to " << pointI
+                    //    << " at:" << pt
+                    //    << endl;
+
+                    patchAttraction[pointI] = nearestAttraction[pointI];
+
+                    if (strPtr.valid())
+                    {
+                        strPtr().write
+                        (
+                            linePointRef(pt, pt+patchAttraction[pointI])
+                        );
+                    }
+                }
+            }
+            else
+            {
+                scalar oldArea = f.mag(pp.localPoints());
+                scalar newArea = singleF.mag(points);
+                if (newArea < 0.1*oldArea)
+                {
+                    // For now remove the point with largest distance
+                    label maxFp = -1;
+                    scalar maxS = -1;
+                    forAll(f, fp)
+                    {
+                        scalar s = magSqr(patchAttraction[f[fp]]);
+                        if (s > maxS)
+                        {
+                            maxS = s;
+                            maxFp = fp;
+                        }
+                    }
+                    if (maxFp != -1)
+                    {
+                        label pointI = f[maxFp];
+                        // Lower attraction on pointI
+                        patchAttraction[pointI] *= 0.5;
+                    }
                 }
             }
         }
@@ -3053,15 +3576,20 @@ void Foam::autoSnapDriver::preventFaceSqueeze
 Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
 (
     const snapParameters& snapParams,
-    const bool avoidSnapProblems,
+    const bool alignMeshEdges,
     const label iter,
     const scalar featureCos,
     const scalar featureAttract,
     const scalarField& snapDist,
     const vectorField& nearestDisp,
+    const vectorField& nearestNormal,
     motionSmoother& meshMover,
     vectorField& patchAttraction,
-    List<pointConstraint>& patchConstraints
+    List<pointConstraint>& patchConstraints,
+
+    DynamicList<label>& splitFaces,
+    DynamicList<labelPair>& splits
+
 ) const
 {
     const Switch implicitFeatureAttraction = snapParams.implicitFeatureSnap();
@@ -3080,6 +3608,7 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
     const fvMesh& mesh = meshRefiner_.mesh();
 
 
+    const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
 
     // Per point, per surrounding face:
     // - faceSurfaceNormal
@@ -3112,7 +3641,7 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
         // normal of surface at point on surface
         vectorField faceSurfaceNormal(pp.size(), vector::zero);
         labelList faceSurfaceGlobalRegion(pp.size(), -1);
-        vectorField faceRotation(pp.size(), vector::zero);
+        //vectorField faceRotation(pp.size(), vector::zero);
 
         calcNearestFace
         (
@@ -3121,8 +3650,8 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
             faceSnapDist,
             faceDisp,
             faceSurfaceNormal,
-            faceSurfaceGlobalRegion,
-            faceRotation
+            faceSurfaceGlobalRegion
+            //faceRotation
         );
 
 
@@ -3173,7 +3702,6 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
         featureAttractionUsingReconstruction
         (
             iter,
-            avoidSnapProblems,
             featureCos,
 
             pp,
@@ -3192,6 +3720,18 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
 
     if (explicitFeatureAttraction)
     {
+        // Only do fancy stuff if alignMeshEdges
+        bool releasePoints = false;
+        bool stringFeatures = false;
+        bool avoidDiagonal = false;
+        if (alignMeshEdges)
+        {
+            releasePoints = snapParams.releasePoints();
+            stringFeatures = snapParams.stringFeatures();
+            avoidDiagonal = snapParams.avoidDiagonal();
+        }
+
+
         // Sample faces around each point and see if nearest surface normal
         // differs. For those find the nearest real feature edge/point and
         // store the correspondence. Then loop over feature edge/point
@@ -3201,13 +3741,19 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
         featureAttractionUsingFeatureEdges
         (
             iter,
-            avoidSnapProblems,
-            featureCos,
             multiRegionFeatureSnap,
 
+            snapParams.detectBaffles(),
+            releasePoints,
+            stringFeatures,
+            avoidDiagonal,
+
+            featureCos,
+
             pp,
             snapDist,
             nearestDisp,
+            nearestNormal,
 
             pointFaceSurfNormals,
             pointFaceDisp,
@@ -3219,6 +3765,46 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
         );
     }
 
+    if (!alignMeshEdges)
+    {
+        const scalar concaveCos = Foam::cos
+        (
+            degToRad(snapParams.concaveAngle())
+        );
+        const scalar minAreaRatio = snapParams.minAreaRatio();
+
+        Info<< "Experimental: introducing face splits to avoid rotating"
+            << " mesh edges. Splitting faces when" << nl
+            << indent << "- angle not concave by more than "
+            << snapParams.concaveAngle() << " degrees" << nl
+            << indent << "- resulting triangles of similar area "
+            << " (ratio within " << minAreaRatio << ")" << nl
+            << endl;
+
+        splitDiagonals
+        (
+            featureCos,
+            concaveCos,
+            minAreaRatio,
+            pp,
+
+            nearestDisp,
+            nearestNormal,
+
+            patchAttraction,
+            patchConstraints,
+            splitFaces,
+            splits
+        );
+
+        if (debug)
+        {
+            Info<< "Diagonal attraction feature correction : ";
+            writeStats(pp, isMasterPoint, patchConstraints);
+        }
+    }
+
+
     preventFaceSqueeze
     (
         iter,
@@ -3226,12 +3812,12 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
 
         pp,
         snapDist,
+        nearestDisp,
 
         patchAttraction,
         patchConstraints
     );
 
-    const PackedBoolList isMasterPoint(syncTools::getMasterPoints(mesh));
     {
         vector avgPatchDisp = meshRefinement::gAverage
         (
@@ -3280,47 +3866,8 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurfaceFeature
 
     // Count
     {
-        const labelList& meshPoints = pp.meshPoints();
-
-        label nMasterPoints = 0;
-        label nPlanar = 0;
-        label nEdge = 0;
-        label nPoint = 0;
-
-        forAll(patchConstraints, pointI)
-        {
-            if (isMasterPoint[meshPoints[pointI]])
-            {
-                nMasterPoints++;
-
-                if (patchConstraints[pointI].first() == 1)
-                {
-                    nPlanar++;
-                }
-                else if (patchConstraints[pointI].first() == 2)
-                {
-                    nEdge++;
-                }
-                else if (patchConstraints[pointI].first() == 3)
-                {
-                    nPoint++;
-                }
-            }
-        }
-
-        reduce(nMasterPoints, sumOp<label>());
-        reduce(nPlanar, sumOp<label>());
-        reduce(nEdge, sumOp<label>());
-        reduce(nPoint, sumOp<label>());
-        Info<< "Feature analysis : total master points:"
-            << nMasterPoints
-            << " attraction to :" << nl
-            << "    feature point   : " << nPoint << nl
-            << "    feature edge    : " << nEdge << nl
-            << "    nearest surface : " << nPlanar << nl
-            << "    rest            : " << nMasterPoints-nPoint-nEdge-nPlanar
-            << nl
-            << endl;
+        Info<< "Feature analysis : ";
+        writeStats(pp, isMasterPoint, patchConstraints);
     }
 
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
index be4272e37a..f99a28481d 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.C
@@ -124,6 +124,14 @@ Foam::layerParameters::layerParameters
         readScalar(dict.lookup("minThickness"))
     ),
     featureAngle_(readScalar(dict.lookup("featureAngle"))),
+    mergePatchFacesAngle_
+    (
+        dict.lookupOrDefault<scalar>
+        (
+            "mergePatchFacesAngle",
+            0.5*featureAngle_
+        )
+    ),
     concaveAngle_
     (
         dict.lookupOrDefault("concaveAngle", defaultConcaveAngle)
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
index 21d52fdd69..bc1a0bb3fd 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/layerParameters/layerParameters.H
@@ -114,6 +114,8 @@ private:
 
         scalar featureAngle_;
 
+        scalar mergePatchFacesAngle_;
+
         scalar concaveAngle_;
 
         label nGrow_;
@@ -247,6 +249,11 @@ public:
                 return featureAngle_;
             }
 
+            scalar mergePatchFacesAngle() const
+            {
+                return mergePatchFacesAngle_;
+            }
+
             scalar concaveAngle() const
             {
                 return concaveAngle_;
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
index 0ed25cf81c..e7af9a60f2 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.C
@@ -27,6 +27,8 @@ License
 #include "unitConversion.H"
 #include "polyMesh.H"
 #include "globalIndex.H"
+#include "Tuple2.H"
+#include "wallPolyPatch.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -44,7 +46,15 @@ Foam::refinementParameters::refinementParameters(const dictionary& dict)
         )
     ),
     nBufferLayers_(readLabel(dict.lookup("nCellsBetweenLevels"))),
-    keepPoints_(pointField(1, dict.lookup("locationInMesh"))),
+    locationsOutsideMesh_
+    (
+        dict.lookupOrDefault
+        (
+            "locationsOutsideMesh",
+            pointField(0)
+        )
+    ),
+    faceZoneControls_(dict.subOrEmptyDict("faceZoneControls")),
     allowFreeStandingZoneFaces_(dict.lookup("allowFreeStandingZoneFaces")),
     useTopologicalSnapDetection_
     (
@@ -56,6 +66,29 @@ Foam::refinementParameters::refinementParameters(const dictionary& dict)
         dict.lookupOrDefault<Switch>("handleSnapProblems", true)
     )
 {
+    point locationInMesh;
+    if (dict.readIfPresent("locationInMesh", locationInMesh))
+    {
+        locationsInMesh_.append(locationInMesh);
+        zonesInMesh_.append("noneIfNotSet");// special name for no cellZone
+    }
+
+    List<Tuple2<point, word> > pointsToZone;
+    if (dict.readIfPresent("locationsInMesh", pointsToZone))
+    {
+        label nZones = locationsInMesh_.size();
+        locationsInMesh_.setSize(nZones+pointsToZone.size());
+        zonesInMesh_.setSize(locationsInMesh_.size());
+
+        forAll(pointsToZone, i)
+        {
+            locationsInMesh_[nZones] = pointsToZone[i].first();
+            zonesInMesh_[nZones] = pointsToZone[i].second();
+            nZones++;
+        }
+    }
+
+
     scalar featAngle(readScalar(dict.lookup("resolveFeatureAngle")));
 
     if (featAngle < 0 || featAngle > 180)
@@ -71,8 +104,68 @@ Foam::refinementParameters::refinementParameters(const dictionary& dict)
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::labelList Foam::refinementParameters::findCells(const polyMesh& mesh)
-const
+Foam::dictionary Foam::refinementParameters::getZoneInfo
+(
+    const word& fzName,
+    surfaceZonesInfo::faceZoneType& faceType
+) const
+{
+    dictionary patchInfo;
+    patchInfo.add("type", wallPolyPatch::typeName);
+    faceType = surfaceZonesInfo::INTERNAL;
+
+    if (faceZoneControls_.found(fzName))
+    {
+        const dictionary& fzDict = faceZoneControls_.subDict(fzName);
+
+        if (fzDict.found("patchInfo"))
+        {
+            patchInfo = fzDict.subDict("patchInfo");
+        }
+
+        word faceTypeName;
+        if (fzDict.readIfPresent("faceType", faceTypeName))
+        {
+            faceType = surfaceZonesInfo::faceZoneTypeNames[faceTypeName];
+        }
+    }
+    return patchInfo;
+}
+
+
+Foam::labelList Foam::refinementParameters::addCellZonesToMesh
+(
+    polyMesh& mesh
+) const
+{
+    labelList zoneIDs(zonesInMesh_.size(), -1);
+    forAll(zonesInMesh_, i)
+    {
+        if
+        (
+            zonesInMesh_[i] != word::null
+         && zonesInMesh_[i] != "none"
+         && zonesInMesh_[i] != "noneIfNotSet"
+        )
+        {
+            zoneIDs[i] = surfaceZonesInfo::addCellZone
+            (
+                zonesInMesh_[i],    // name
+                labelList(0),       // addressing
+                mesh
+            );
+        }
+    }
+    return zoneIDs;
+}
+
+
+Foam::labelList Foam::refinementParameters::findCells
+(
+    const bool checkInsideMesh,
+    const polyMesh& mesh,
+    const pointField& locations
+)
 {
     // Force calculation of tet-diag decomposition (for use in findCell)
     (void)mesh.tetBasePtIs();
@@ -81,13 +174,13 @@ const
     globalIndex globalCells(mesh.nCells());
 
     // Cell label per point
-    labelList cellLabels(keepPoints_.size());
+    labelList cellLabels(locations.size());
 
-    forAll(keepPoints_, i)
+    forAll(locations, i)
     {
-        const point& keepPoint = keepPoints_[i];
+        const point& location = locations[i];
 
-        label localCellI = mesh.findCell(keepPoint);
+        label localCellI = mesh.findCell(location);
 
         label globalCellI = -1;
 
@@ -98,12 +191,13 @@ const
 
         reduce(globalCellI, maxOp<label>());
 
-        if (globalCellI == -1)
+        if (checkInsideMesh && globalCellI == -1)
         {
             FatalErrorIn
             (
-                "refinementParameters::findCells(const polyMesh&) const"
-            )   << "Point " << keepPoint
+                "refinementParameters::findCells"
+                "(const polyMesh&, const pointField&) const"
+            )   << "Point " << location
                 << " is not inside the mesh or on a face or edge." << nl
                 << "Bounding box of the mesh:" << mesh.bounds()
                 << exit(FatalError);
@@ -113,10 +207,9 @@ const
         label procI = globalCells.whichProcID(globalCellI);
         label procCellI = globalCells.toLocal(procI, globalCellI);
 
-        Info<< "Found point " << keepPoint << " in cell " << procCellI
+        Info<< "Found point " << location << " in cell " << procCellI
             << " on processor " << procI << endl;
 
-
         if (globalCells.isLocal(globalCellI))
         {
             cellLabels[i] = localCellI;
@@ -130,4 +223,48 @@ const
 }
 
 
+Foam::labelList Foam::refinementParameters::zonedLocations
+(
+    const wordList& zonesInMesh
+)
+{
+    DynamicList<label> indices(zonesInMesh.size());
+
+    forAll(zonesInMesh, i)
+    {
+        if
+        (
+            zonesInMesh[i] == word::null
+        ||  zonesInMesh[i] != "noneIfNotSet"
+        )
+        {
+            indices.append(i);
+        }
+    }
+    return indices;
+}
+
+
+Foam::labelList Foam::refinementParameters::unzonedLocations
+(
+    const wordList& zonesInMesh
+)
+{
+    DynamicList<label> indices(0);
+
+    forAll(zonesInMesh, i)
+    {
+        if
+        (
+            zonesInMesh[i] != word::null
+        &&  zonesInMesh[i] == "noneIfNotSet"
+        )
+        {
+            indices.append(i);
+        }
+    }
+    return indices;
+}
+
+
 // ************************************************************************* //
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
index 06b90b0758..4d00183195 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/refinementParameters.H
@@ -38,6 +38,8 @@ SourceFiles
 #include "dictionary.H"
 #include "pointField.H"
 #include "Switch.H"
+#include "wordPairHashTable.H"
+#include "surfaceZonesInfo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -73,8 +75,21 @@ class refinementParameters
         //- Number of layers between different refinement levels
         const label nBufferLayers_;
 
-        //- Areas to keep
-        const pointField keepPoints_;
+
+        // Selection of areas
+
+            //- Areas not to keep
+            const pointField locationsOutsideMesh_;
+
+            //- Areas to keep
+            pointField locationsInMesh_;
+
+            //- Region for location
+            wordList zonesInMesh_;
+
+            //- Information on how to handle faces on faceZones
+            dictionary faceZoneControls_;
+
 
         //- FaceZone faces allowed which have owner and neighbour in same
         //  cellZone?
@@ -147,9 +162,21 @@ public:
             }
 
             //- Areas to keep
-            const pointField& keepPoints() const
+            const pointField& locationsInMesh() const
             {
-                return keepPoints_;
+                return locationsInMesh_;
+            }
+
+            //- Per area the zone name
+            const wordList& zonesInMesh() const
+            {
+                return zonesInMesh_;
+            }
+
+            //- Optional points which are checked to be outside the mesh
+            const pointField& locationsOutsideMesh() const
+            {
+                return locationsOutsideMesh_;
             }
 
             //- Are zone faces allowed only inbetween different cell zones
@@ -180,8 +207,30 @@ public:
 
         // Other
 
-            //- Checks that cells are in mesh. Returns cells they are in.
-            labelList findCells(const polyMesh&) const;
+            //- Get patchInfo and faceType for faceZone
+            dictionary getZoneInfo
+            (
+                const word& fzName,
+                surfaceZonesInfo::faceZoneType& faceType
+            ) const;
+
+            //- Add cellZones to mesh. Return indices of cellZones (or -1)
+            labelList addCellZonesToMesh(polyMesh&) const;
+
+            //- Checks that cells are in mesh. Returns cells (or -1) they
+            //  are in.
+            static labelList findCells
+            (
+                const bool checkInsideMesh,
+                const polyMesh&,
+                const pointField& locations
+            );
+
+            //- Extract indices of named locations (so excludes 'keepPoints')
+            static labelList zonedLocations(const wordList& zonesInMesh);
+
+            //- Extract indices of unnamed locations ('keepPoints')
+            static labelList unzonedLocations(const wordList& zonesInMesh);
 
 };
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/wordPairHashTable.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/wordPairHashTable.H
new file mode 100644
index 0000000000..a2a7ea414d
--- /dev/null
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/refinementParameters/wordPairHashTable.H
@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Typedef
+    Foam::wordPairHashTable
+
+Description
+    HashTable of Pair<word>
+
+Typedef
+    Foam::wordPairHashTable
+
+Description
+    HashTable of Pair<word>
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef wordPairHashTable_H
+#define wordPairHashTable_H
+
+#include "Pair.H"
+#include "HashTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef HashTable<word, Pair<word>, typename FixedList<word, 2>::Hash<> >
+        wordPairHashTable;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
index 364a6aae49..67e602f109 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,7 +44,17 @@ Foam::snapParameters::snapParameters(const dictionary& dict)
     detectNearSurfacesSnap_
     (
         dict.lookupOrDefault("detectNearSurfacesSnap", true)
-    )
+    ),
+    detectBaffles_(dict.lookupOrDefault("detectBaffles", true)),
+    releasePoints_(dict.lookupOrDefault("releasePoints", false)),
+    stringFeatures_(dict.lookupOrDefault("stringFeatures", true)),
+    avoidDiagonal_(dict.lookupOrDefault("avoidDiagonal", false)),
+    nFaceSplitInterval_
+    (
+        dict.lookupOrDefault("nFaceSplitInterval", labelMin)
+    ),
+    concaveAngle_(dict.lookupOrDefault("concaveAngle", 45)),
+    minAreaRatio_(dict.lookupOrDefault("minAreaRatio", 0.3))
 {}
 
 
diff --git a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
index 5dc4ca34e8..0f431bf4b2 100644
--- a/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
+++ b/src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/snapParameters/snapParameters.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -72,6 +72,24 @@ class snapParameters
 
         const Switch detectNearSurfacesSnap_;
 
+        const Switch detectBaffles_;
+
+        const Switch releasePoints_;
+
+        const Switch stringFeatures_;
+
+        const Switch avoidDiagonal_;
+
+
+        //- How often needs face splitting be run
+        label nFaceSplitInterval_;
+
+        //- When is angle too concave too split
+        scalar concaveAngle_;
+
+        //- When is face-split not sufficiently diagonal
+        scalar minAreaRatio_;
+
 
     // Private Member Functions
 
@@ -123,30 +141,78 @@ public:
                 return nSnap_;
             }
 
-            label nFeatureSnap() const
-            {
-                return nFeatureSnap_;
-            }
 
-            Switch explicitFeatureSnap() const
-            {
-                return explicitFeatureSnap_;
-            }
+            // Surface snapping specific
+
+                Switch detectNearSurfacesSnap() const
+                {
+                    return detectNearSurfacesSnap_;
+                }
+
+
+            // Feature edge snapping specific
+
+                label nFeatureSnap() const
+                {
+                    return nFeatureSnap_;
+                }
+
+                Switch explicitFeatureSnap() const
+                {
+                    return explicitFeatureSnap_;
+                }
+
+                Switch implicitFeatureSnap() const
+                {
+                    return implicitFeatureSnap_;
+                }
+
+                Switch multiRegionFeatureSnap() const
+                {
+                    return multiRegionFeatureSnap_;
+                }
+
+                Switch detectBaffles() const
+                {
+                    return detectBaffles_;
+                }
+
+                Switch releasePoints() const
+                {
+                    return releasePoints_;
+                }
+
+                Switch stringFeatures() const
+                {
+                    return stringFeatures_;
+                }
+
+                Switch avoidDiagonal() const
+                {
+                    return avoidDiagonal_;
+                }
+
+
+                // Face splitting
+
+
+                    label nFaceSplitInterval() const
+                    {
+                        return nFaceSplitInterval_;
+                    }
+
+                    scalar concaveAngle() const
+                    {
+                        return concaveAngle_;
+                    }
+
+                    scalar minAreaRatio() const
+                    {
+                        return minAreaRatio_;
+                    }
 
-            Switch implicitFeatureSnap() const
-            {
-                return implicitFeatureSnap_;
-            }
 
-            Switch multiRegionFeatureSnap() const
-            {
-                return multiRegionFeatureSnap_;
-            }
 
-            Switch detectNearSurfacesSnap() const
-            {
-                return detectNearSurfacesSnap_;
-            }
 
 };
 
diff --git a/src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.C b/src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.C
index b605ae672b..076db077c7 100644
--- a/src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.C
+++ b/src/mesh/autoMesh/autoHexMesh/externalDisplacementMeshMover/medialAxisMeshMover.C
@@ -1203,7 +1203,8 @@ handleFeatureAngleLayerTerminations
 
     //Info<< "Added "
     //    << returnReduce(nPointCounter-nOldPointCounter, sumOp<label>())
-    //    << " point not to extrude." << endl;
+    //    << " point not to extrude due to minCos "
+    //    << minCos << endl;
 }
 
 
@@ -1225,7 +1226,19 @@ void Foam::medialAxisMeshMover::findIsolatedRegions
     const labelListList& pointFaces = pp.pointFaces();
 
 
-    Info<< typeName << " : Removing isolated regions ..." << endl;
+    Info<< typeName << " : Removing isolated regions ..."
+        << indent << "- if partially extruded faces make angle < "
+        << Foam::radToDeg(Foam::acos(minCosLayerTermination)) <<  nl;
+    if (detectExtrusionIsland)
+    {
+        Info<< indent << "- if exclusively surrounded by non-extruded points"
+            << nl;
+    }
+    else
+    {
+        Info<< indent << "- if exclusively surrounded by non-extruded faces"
+            << nl;
+    }
 
     // Keep count of number of points unextruded
     label nPointCounter = 0;
@@ -1234,19 +1247,21 @@ void Foam::medialAxisMeshMover::findIsolatedRegions
     {
         // Stop layer growth where mesh wraps around edge with a
         // large feature angle
-        handleFeatureAngleLayerTerminations
-        (
-            minCosLayerTermination,
-            isMasterPoint,
-            meshEdges,
+        if (minCosLayerTermination > -1)
+        {
+            handleFeatureAngleLayerTerminations
+            (
+                minCosLayerTermination,
+                isMasterPoint,
+                meshEdges,
 
-            extrudeStatus,
-            patchDisp,
-            nPointCounter
-        );
-
-        syncPatchDisplacement(minThickness, patchDisp, extrudeStatus);
+                extrudeStatus,
+                patchDisp,
+                nPointCounter
+            );
 
+            syncPatchDisplacement(minThickness, patchDisp, extrudeStatus);
+        }
 
 
         // Detect either:
@@ -1708,10 +1723,12 @@ void Foam::medialAxisMeshMover::calculateDisplacement
     const scalar featureAngle = readScalar(coeffDict.lookup("featureAngle"));
 
     //- Stop layer growth where mesh wraps around sharp edge
-    const scalar minCosLayerTermination = Foam::cos
+    scalar layerTerminationAngle = coeffDict.lookupOrDefault<scalar>
     (
-        degToRad(0.5*featureAngle)
+        "layerTerminationAngle",
+        0.5*featureAngle
     );
+    scalar minCosLayerTermination = Foam::cos(degToRad(layerTerminationAngle));
 
     //- Smoothing wanted patch thickness
     const label nSmoothPatchThickness = readLabel
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
index e90ccce3fb..9fbb324493 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -56,6 +56,8 @@ License
 #include "treeBoundBox.H"
 #include "zeroGradientFvPatchFields.H"
 #include "fvMeshTools.H"
+#include "motionSmoother.H"
+#include "faceSet.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -177,6 +179,12 @@ void Foam::meshRefinement::calcNeighbourData
                 label own = faceCells[i];
                 label ownLevel = cellLevel[own];
                 label faceLevel = meshCutter_.getAnchorLevel(pp.start()+i);
+                if (faceLevel < 0)
+                {
+                    // Due to e.g. face merging no longer a consistent
+                    // refinementlevel of face. Assume same as cell
+                    faceLevel = ownLevel;
+                }
 
                 // Normal distance from face centre to cell centre
                 scalar d = ((faceCentres[i] - cellCentres[own]) & fn);
@@ -545,7 +553,13 @@ void Foam::meshRefinement::checkData()
                         << " current:" << surfaceHit[faceI]
                         << " ownCc:"
                         << mesh_.cellCentres()[mesh_.faceOwner()[faceI]]
+                        << " neiCc:"
+                        << neiCc[faceI-mesh_.nInternalFaces()]
                         << " end:" << end[faceI]
+                        << " ownLevel:"
+                        << meshCutter_.cellLevel()[mesh_.faceOwner()[faceI]]
+                        << " faceLevel:"
+                        << meshCutter_.getAnchorLevel(faceI)
                         << endl;
                 }
             }
@@ -678,20 +692,19 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRemoveCells
 
 
 // Split faces
-Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitFaces
+void Foam::meshRefinement::doSplitFaces
 (
     const labelList& splitFaces,
-    const labelPairList& splits
-)
+    const labelPairList& splits,
+    //const List<Pair<point> >& splitPoints,
+    polyTopoChange& meshMod
+) const
 {
-    polyTopoChange meshMod(mesh_);
-
     forAll(splitFaces, i)
     {
         label faceI = splitFaces[i];
         const face& f = mesh_.faces()[faceI];
 
-
         // Split as start and end index in face
         const labelPair& split = splits[i];
 
@@ -744,9 +757,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitFaces
         }
 
 
-Pout<< "face:" << faceI << " verts:" << f
-    << " split into f0:" << f0
-    << " f1:" << f1 << endl;
+        //Pout<< "face:" << faceI << " verts:" << f
+        //    << " split into f0:" << f0
+        //    << " f1:" << f1 << endl;
 
         // Change/add faces
         meshMod.modifyFace
@@ -773,396 +786,384 @@ Pout<< "face:" << faceI << " verts:" << f
             zoneI,                      // zone for face
             zoneFlip                    // face flip in zone
         );
+
+
+        //// Move points
+        //meshMod.modifyPoint
+        //(
+        //    f[split[0]],
+        //    splitPoints[i][0],
+        //    -1,
+        //    true
+        //);
+        //meshMod.modifyPoint
+        //(
+        //    f[split[1]],
+        //    splitPoints[i][1],
+        //    -1,
+        //    true
+        //);
     }
-
-
-
-    // Change the mesh (no inflation)
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields
-    mesh_.updateMesh(map);
-
-    // Move mesh (since morphing might not do this)
-    if (map().hasMotionPoints())
-    {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-    else
-    {
-        // Delete mesh volumes. No other way to do this?
-        mesh_.clearOut();
-    }
-
-    // Reset the instance for if in overwrite mode
-    mesh_.setInstance(timeName());
-    setInstance(mesh_.facesInstance());
-
-    // Update local mesh data
-    const labelList& oldToNew = map().reverseFaceMap();
-    labelList newSplitFaces(renumber(oldToNew, splitFaces));
-    // Add added faces (every splitFaces becomes two faces)
-    label sz = newSplitFaces.size();
-    newSplitFaces.setSize(2*sz);
-    forAll(map().faceMap(), faceI)
-    {
-        label oldFaceI = map().faceMap()[faceI];
-        if (oldToNew[oldFaceI] != faceI)
-        {
-            // Added face
-            newSplitFaces[sz++] = faceI;
-        }
-    }
-
-    updateMesh(map, newSplitFaces);
-
-    return map;
 }
 
 
-//// Determine for multi-processor regions the lowest numbered cell on the
-//// lowest numbered processor.
-//void Foam::meshRefinement::getCoupledRegionMaster
-//(
-//    const globalIndex& globalCells,
-//    const boolList& blockedFace,
-//    const regionSplit& globalRegion,
-//    Map<label>& regionToMaster
-//) const
-//{
-//    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-//
-//    forAll(patches, patchI)
-//    {
-//        const polyPatch& pp = patches[patchI];
-//
-//        if (isA<processorPolyPatch>(pp))
-//        {
-//            forAll(pp, i)
-//            {
-//                label faceI = pp.start()+i;
-//
-//                if (!blockedFace[faceI])
-//                {
-//                    // Only if there is a connection to the neighbour
-//                    // will there be a multi-domain region; if not through
-//                    // this face then through another.
-//
-//                    label cellI = mesh_.faceOwner()[faceI];
-//                    label globalCellI = globalCells.toGlobal(cellI);
-//
-//                    Map<label>::iterator iter =
-//                        regionToMaster.find(globalRegion[cellI]);
-//
-//                    if (iter != regionToMaster.end())
-//                    {
-//                        label master = iter();
-//                        iter() = min(master, globalCellI);
-//                    }
-//                    else
-//                    {
-//                        regionToMaster.insert
-//                        (
-//                            globalRegion[cellI],
-//                            globalCellI
-//                        );
-//                    }
-//                }
-//            }
-//        }
-//    }
-//
-//    // Do reduction
-//    Pstream::mapCombineGather(regionToMaster, minEqOp<label>());
-//    Pstream::mapCombineScatter(regionToMaster);
-//}
-//
-//
-//void Foam::meshRefinement::calcLocalRegions
-//(
-//    const globalIndex& globalCells,
-//    const labelList& globalRegion,
-//    const Map<label>& coupledRegionToMaster,
-//    const scalarField& cellWeights,
-//
-//    Map<label>& globalToLocalRegion,
-//    pointField& localPoints,
-//    scalarField& localWeights
-//) const
-//{
-//    globalToLocalRegion.resize(globalRegion.size());
-//    DynamicList<point> localCc(globalRegion.size()/2);
-//    DynamicList<scalar> localWts(globalRegion.size()/2);
-//
-//    forAll(globalRegion, cellI)
-//    {
-//        Map<label>::const_iterator fndMaster =
-//            coupledRegionToMaster.find(globalRegion[cellI]);
-//
-//        if (fndMaster != coupledRegionToMaster.end())
-//        {
-//            // Multi-processor region.
-//            if (globalCells.toGlobal(cellI) == fndMaster())
-//            {
-//                // I am master. Allocate region for me.
-//                globalToLocalRegion.insert
-//                (
-//                    globalRegion[cellI],
-//                    localCc.size()
-//                );
-//                localCc.append(mesh_.cellCentres()[cellI]);
-//                localWts.append(cellWeights[cellI]);
-//            }
-//        }
-//        else
-//        {
-//            // Single processor region.
-//            if
-//            (
-//                globalToLocalRegion.insert
-//                (
-//                    globalRegion[cellI],
-//                    localCc.size()
-//                )
-//            )
-//            {
-//                localCc.append(mesh_.cellCentres()[cellI]);
-//                localWts.append(cellWeights[cellI]);
-//            }
-//        }
-//    }
-//
-//    localPoints.transfer(localCc);
-//    localWeights.transfer(localWts);
-//
-//    if (localPoints.size() != globalToLocalRegion.size())
-//    {
-//        FatalErrorIn("calcLocalRegions(..)")
-//            << "localPoints:" << localPoints.size()
-//            << " globalToLocalRegion:" << globalToLocalRegion.size()
-//            << exit(FatalError);
-//    }
-//}
-//
-//
-//Foam::label Foam::meshRefinement::getShiftedRegion
-//(
-//    const globalIndex& indexer,
-//    const Map<label>& globalToLocalRegion,
-//    const Map<label>& coupledRegionToShifted,
-//    const label globalRegion
-//)
-//{
-//    Map<label>::const_iterator iter =
-//        globalToLocalRegion.find(globalRegion);
-//
-//    if (iter != globalToLocalRegion.end())
-//    {
-//        // Region is 'owned' locally. Convert local region index into global.
-//        return indexer.toGlobal(iter());
-//    }
-//    else
-//    {
-//        return coupledRegionToShifted[globalRegion];
-//    }
-//}
-//
-//
-//// Add if not yet present
-//void Foam::meshRefinement::addUnique(const label elem, labelList& lst)
-//{
-//    if (findIndex(lst, elem) == -1)
-//    {
-//        label sz = lst.size();
-//        lst.setSize(sz+1);
-//        lst[sz] = elem;
-//    }
-//}
-//
-//
-//void Foam::meshRefinement::calcRegionRegions
-//(
-//    const labelList& globalRegion,
-//    const Map<label>& globalToLocalRegion,
-//    const Map<label>& coupledRegionToMaster,
-//    labelListList& regionRegions
-//) const
-//{
-//    // Global region indexing since we now know the shifted regions.
-//    globalIndex shiftIndexer(globalToLocalRegion.size());
-//
-//    // Redo the coupledRegionToMaster to be in shifted region indexing.
-//    Map<label> coupledRegionToShifted(coupledRegionToMaster.size());
-//    forAllConstIter(Map<label>, coupledRegionToMaster, iter)
-//    {
-//        label region = iter.key();
-//
-//        Map<label>::const_iterator fndRegion = globalToLocalRegion.find
-//        (region);
-//
-//        if (fndRegion != globalToLocalRegion.end())
-//        {
-//            // A local cell is master of this region. Get its shifted region.
-//            coupledRegionToShifted.insert
-//            (
-//                region,
-//                shiftIndexer.toGlobal(fndRegion())
-//            );
-//        }
-//        Pstream::mapCombineGather(coupledRegionToShifted, minEqOp<label>());
-//        Pstream::mapCombineScatter(coupledRegionToShifted);
-//    }
-//
-//
-//    // Determine region-region connectivity.
-//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//    // This is for all my regions (so my local ones or the ones I am master
-//    // of) the neighbouring region indices.
-//
-//
-//    // Transfer lists.
-//    PtrList<HashSet<edge, Hash<edge> > > regionConnectivity
-//    (Pstream::nProcs());
-//    forAll(regionConnectivity, procI)
-//    {
-//        if (procI != Pstream::myProcNo())
-//        {
-//            regionConnectivity.set
-//            (
-//                procI,
-//                new HashSet<edge, Hash<edge> >
-//                (
-//                    coupledRegionToShifted.size()
-//                  / Pstream::nProcs()
-//                )
-//            );
-//        }
-//    }
-//
-//
-//    // Connectivity. For all my local regions the connected regions.
-//    regionRegions.setSize(globalToLocalRegion.size());
-//
-//    // Add all local connectivity to regionRegions; add all non-local
-//    // to the transferlists.
-//    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
-//    {
-//        label ownRegion = globalRegion[mesh_.faceOwner()[faceI]];
-//        label neiRegion = globalRegion[mesh_.faceNeighbour()[faceI]];
-//
-//        if (ownRegion != neiRegion)
-//        {
-//            label shiftOwnRegion = getShiftedRegion
-//            (
-//                shiftIndexer,
-//                globalToLocalRegion,
-//                coupledRegionToShifted,
-//                ownRegion
-//            );
-//            label shiftNeiRegion = getShiftedRegion
-//            (
-//                shiftIndexer,
-//                globalToLocalRegion,
-//                coupledRegionToShifted,
-//                neiRegion
-//            );
-//
-//
-//            // Connection between two regions. Send to owner of region.
-//            // - is ownRegion 'owned' by me
-//            // - is neiRegion 'owned' by me
-//
-//            if (shiftIndexer.isLocal(shiftOwnRegion))
-//            {
-//                label localI = shiftIndexer.toLocal(shiftOwnRegion);
-//                addUnique(shiftNeiRegion, regionRegions[localI]);
-//            }
-//            else
-//            {
-//                label masterProc = shiftIndexer.whichProcID(shiftOwnRegion);
-//                regionConnectivity[masterProc].insert
-//                (
-//                    edge(shiftOwnRegion, shiftNeiRegion)
-//                );
-//            }
-//
-//            if (shiftIndexer.isLocal(shiftNeiRegion))
-//            {
-//                label localI = shiftIndexer.toLocal(shiftNeiRegion);
-//                addUnique(shiftOwnRegion, regionRegions[localI]);
-//            }
-//            else
-//            {
-//                label masterProc = shiftIndexer.whichProcID(shiftNeiRegion);
-//                regionConnectivity[masterProc].insert
-//                (
-//                    edge(shiftOwnRegion, shiftNeiRegion)
-//                );
-//            }
-//        }
-//    }
-//
-//
-//    // Send
-//    forAll(regionConnectivity, procI)
-//    {
-//        if (procI != Pstream::myProcNo())
-//        {
-//            OPstream str(Pstream::blocking, procI);
-//            str << regionConnectivity[procI];
-//        }
-//    }
-//    // Receive
-//    forAll(regionConnectivity, procI)
-//    {
-//        if (procI != Pstream::myProcNo())
-//        {
-//            IPstream str(Pstream::blocking, procI);
-//            str >> regionConnectivity[procI];
-//        }
-//    }
-//
-//    // Add to addressing.
-//    forAll(regionConnectivity, procI)
-//    {
-//        if (procI != Pstream::myProcNo())
-//        {
-//            for
-//            (
-//                HashSet<edge, Hash<edge> >::const_iterator iter =
-//                    regionConnectivity[procI].begin();
-//                iter != regionConnectivity[procI].end();
-//                ++iter
-//            )
-//            {
-//                const edge& e = iter.key();
-//
-//                bool someLocal = false;
-//                if (shiftIndexer.isLocal(e[0]))
-//                {
-//                    label localI = shiftIndexer.toLocal(e[0]);
-//                    addUnique(e[1], regionRegions[localI]);
-//                    someLocal = true;
-//                }
-//                if (shiftIndexer.isLocal(e[1]))
-//                {
-//                    label localI = shiftIndexer.toLocal(e[1]);
-//                    addUnique(e[0], regionRegions[localI]);
-//                    someLocal = true;
-//                }
-//
-//                if (!someLocal)
-//                {
-//                    FatalErrorIn("calcRegionRegions(..)")
-//                        << "Received from processor " << procI
-//                        << " connection " << e
-//                        << " where none of the elements is local to me."
-//                        << abort(FatalError);
-//                }
-//            }
-//        }
-//    }
-//}
+Foam::label Foam::meshRefinement::splitFacesUndo
+(
+    const labelList& splitFaces,
+    const labelPairList& splits,
+    const dictionary& motionDict,
+
+    labelList& duplicateFace,
+    List<labelPair>& baffles
+)
+{
+    label nSplit = returnReduce(splitFaces.size(), sumOp<label>());
+    Info<< nl
+        << "Splitting " << nSplit
+        << " faces across diagonals" << "." << nl << endl;
+
+    // To undo: store original faces
+    faceList originalFaces(UIndirectList<face>(mesh_.faces(), splitFaces));
+    labelPairList facePairs(splitFaces.size(), labelPair(-1, -1));
+
+
+    {
+        polyTopoChange meshMod(mesh_);
+        meshMod.setCapacity
+        (
+            meshMod.points().size(),
+            meshMod.faces().size()+splitFaces.size(),
+            mesh_.nCells()
+        );
+
+        // Insert the mesh changes
+        doSplitFaces(splitFaces, splits, meshMod);
+
+        // Change the mesh (no inflation)
+        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing might not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+        setInstance(mesh_.facesInstance());
+
+
+        // Update local mesh data
+        // ~~~~~~~~~~~~~~~~~~~~~~
+
+        forAll(originalFaces, i)
+        {
+            inplaceRenumber(map().reversePointMap(), originalFaces[i]);
+        }
+
+        {
+            Map<label> splitFaceToIndex(2*splitFaces.size());
+            forAll(splitFaces, i)
+            {
+                splitFaceToIndex.insert(splitFaces[i], i);
+            }
+
+            forAll(map().faceMap(), faceI)
+            {
+                label oldFaceI = map().faceMap()[faceI];
+                Map<label>::iterator oldFaceFnd = splitFaceToIndex.find
+                (
+                    oldFaceI
+                );
+                if (oldFaceFnd != splitFaceToIndex.end())
+                {
+                    labelPair& twoFaces = facePairs[oldFaceFnd()];
+                    if (twoFaces[0] == -1)
+                    {
+                        twoFaces[0] = faceI;
+                    }
+                    else if (twoFaces[1] == -1)
+                    {
+                        twoFaces[1] = faceI;
+                    }
+                    else
+                    {
+                        FatalErrorIn("meshRefinement::splitFacesUndo()")
+                            << "problem: twoFaces:" << twoFaces
+                            << exit(FatalError);
+                    }
+                }
+            }
+        }
+
+
+        // Update baffle data
+        // ~~~~~~~~~~~~~~~~~~
+
+        if (duplicateFace.size())
+        {
+            meshRefinement::updateList(map().faceMap(), -1, duplicateFace);
+        }
+
+        const labelList& oldToNewFaces = map().reverseFaceMap();
+        forAll(baffles, i)
+        {
+            labelPair& baffle = baffles[i];
+            baffle.first() = oldToNewFaces[baffle.first()];
+            baffle.second() = oldToNewFaces[baffle.second()];
+
+            if (baffle.first() == -1 || baffle.second() == -1)
+            {
+                FatalErrorIn("meshRefinement::splitFacesUndo()")
+                    << "Removed baffle : faces:" << baffle
+                    << exit(FatalError);
+            }
+        }
+
+
+        // Update insersections
+        // ~~~~~~~~~~~~~~~~~~~~
+
+        {
+            DynamicList<label> changedFaces(facePairs.size());
+            forAll(facePairs, i)
+            {
+                changedFaces.append(facePairs[i].first());
+                changedFaces.append(facePairs[i].second());
+            }
+
+            // Update intersections on changed faces
+            updateMesh(map, growFaceCellFace(changedFaces));
+        }
+    }
+
+
+
+    // Undo loop
+    // ~~~~~~~~~
+    // Maintains two bits of information:
+    // facePairs     : two faces originating from the same face
+    // originalFaces : original face in current vertices
+
+
+    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 (!hasErrors)
+        {
+            break;
+        }
+
+        // Extend faces
+        {
+            const labelList grownFaces(growFaceCellFace(errorFaces));
+            errorFaces.clear();
+            errorFaces.insert(grownFaces);
+        }
+
+
+        // Merge face pairs
+        // ~~~~~~~~~~~~~~~~
+        // (if one of the faces is in the errorFaces set)
+
+        polyTopoChange meshMod(mesh_);
+
+        // Indices (in facePairs) of merged faces
+        labelHashSet mergedIndices(facePairs.size());
+        forAll(facePairs, index)
+        {
+            const labelPair& twoFaces = facePairs[index];
+
+            if
+            (
+                errorFaces.found(twoFaces.first())
+             || errorFaces.found(twoFaces.second())
+            )
+            {
+                const face& originalFace = originalFaces[index];
+
+
+                // Determine face properties
+                label own = mesh_.faceOwner()[twoFaces[0]];
+                label nei = -1;
+                label patchI = -1;
+                if (twoFaces[0] >= mesh_.nInternalFaces())
+                {
+                    patchI = mesh_.boundaryMesh().whichPatch(twoFaces[0]);
+                }
+                else
+                {
+                    nei = mesh_.faceNeighbour()[twoFaces[0]];
+                }
+
+                label zoneI = mesh_.faceZones().whichZone(twoFaces[0]);
+                bool zoneFlip = false;
+                if (zoneI != -1)
+                {
+                    const faceZone& fz = mesh_.faceZones()[zoneI];
+                    zoneFlip = fz.flipMap()[fz.whichFace(twoFaces[0])];
+                }
+
+                // Modify first face
+                meshMod.modifyFace
+                (
+                    originalFace,               // modified face
+                    twoFaces[0],                // label of face
+                    own,                        // owner
+                    nei,                        // neighbour
+                    false,                      // face flip
+                    patchI,                     // patch for face
+                    zoneI,                      // zone for face
+                    zoneFlip                    // face flip in zone
+                );
+                // Merge second face into first
+                meshMod.removeFace(twoFaces[1], twoFaces[0]);
+
+                mergedIndices.insert(index);
+            }
+        }
+
+        label n = returnReduce(mergedIndices.size(), sumOp<label>());
+
+        Info<< "Detected " << n
+            << " split faces that will be restored to their original faces."
+            << nl << endl;
+
+        if (n == 0)
+        {
+            // Nothing to be restored
+            break;
+        }
+
+        nSplit -= n;
+
+
+        // Change the mesh (no inflation)
+        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing might not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+        setInstance(mesh_.facesInstance());
+
+
+        // Update local mesh data
+        // ~~~~~~~~~~~~~~~~~~~~~~
+
+        {
+            const labelList& oldToNewFaces = map().reverseFaceMap();
+            const labelList& oldToNewPoints = map().reversePointMap();
+
+            // Compact out merged faces
+            DynamicList<label> changedFaces(mergedIndices.size());
+
+            label newIndex = 0;
+            forAll(facePairs, index)
+            {
+                const labelPair& oldSplit = facePairs[index];
+                label new0 = oldToNewFaces[oldSplit[0]];
+                label new1 = oldToNewFaces[oldSplit[1]];
+
+                if (!mergedIndices.found(index))
+                {
+                    // Faces still split
+                    if (new0 < 0 || new1 < 0)
+                    {
+                        FatalErrorIn("meshRefinement::splitFacesUndo()")
+                            << "Problem: oldFaces:" << oldSplit
+                            << " newFaces:" << labelPair(new0, new1)
+                            << exit(FatalError);
+                    }
+
+                    facePairs[newIndex] = labelPair(new0, new1);
+                    originalFaces[newIndex] = renumber
+                    (
+                        oldToNewPoints,
+                        originalFaces[index]
+                    );
+                    newIndex++;
+                }
+                else
+                {
+                    // Merged face. Only new0 kept.
+                    if (new0 < 0 || new1 == -1)
+                    {
+                        FatalErrorIn("meshRefinement::splitFacesUndo()")
+                            << "Problem: oldFaces:" << oldSplit
+                            << " newFace:" << labelPair(new0, new1)
+                            << exit(FatalError);
+                    }
+                    changedFaces.append(new0);
+                }
+            }
+
+            facePairs.setSize(newIndex);
+            originalFaces.setSize(newIndex);
+
+
+            // Update intersections
+            updateMesh(map, growFaceCellFace(changedFaces));
+        }
+
+        // Update baffle data
+        // ~~~~~~~~~~~~~~~~~~
+        {
+            if (duplicateFace.size())
+            {
+                meshRefinement::updateList(map().faceMap(), -1, duplicateFace);
+            }
+
+            const labelList& reverseFaceMap = map().reverseFaceMap();
+            forAll(baffles, i)
+            {
+                labelPair& baffle = baffles[i];
+                baffle.first() = reverseFaceMap[baffle.first()];
+                baffle.second() = reverseFaceMap[baffle.second()];
+
+                if (baffle.first() == -1 || baffle.second() == -1)
+                {
+                    FatalErrorIn("meshRefinement::splitFacesUndo()")
+                        << "Removed baffle : faces:" << baffle
+                        << exit(FatalError);
+                }
+            }
+        }
+
+    }
+
+    return nSplit;
+}
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -1231,150 +1232,6 @@ Foam::label Foam::meshRefinement::countHits() const
 }
 
 
-//// Determine distribution to move connected regions onto one processor.
-//Foam::labelList Foam::meshRefinement::decomposeCombineRegions
-//(
-//    const scalarField& cellWeights,
-//    const boolList& blockedFace,
-//    const List<labelPair>& explicitConnections,
-//    decompositionMethod& decomposer
-//) const
-//{
-//    // Determine global regions, separated by blockedFaces
-//    regionSplit globalRegion(mesh_, blockedFace, explicitConnections);
-//
-//    // Now globalRegion has global region per cell. Problem is that
-//    // the region might span multiple domains so we want to get
-//    // a "region master" per domain. Note that multi-processor
-//    // regions can only occur on cells on coupled patches.
-//    // Note: since the number of regions does not change by this the
-//    // process can be seen as just a shift of a region onto a single
-//    // processor.
-//
-//
-//    // Global cell numbering engine
-//    globalIndex globalCells(mesh_.nCells());
-//
-//
-//    // Determine per coupled region the master cell (lowest numbered cell
-//    // on lowest numbered processor)
-//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//    // (does not determine master for non-coupled=fully-local regions)
-//
-//    Map<label> coupledRegionToMaster(mesh_.nFaces()-mesh_.nInternalFaces());
-//    getCoupledRegionMaster
-//    (
-//        globalCells,
-//        blockedFace,
-//        globalRegion,
-//        coupledRegionToMaster
-//    );
-//
-//    // Determine my regions
-//    // ~~~~~~~~~~~~~~~~~~~~
-//    // These are the fully local ones or the coupled ones of which I am master
-//
-//    Map<label> globalToLocalRegion;
-//    pointField localPoints;
-//    scalarField localWeights;
-//    calcLocalRegions
-//    (
-//        globalCells,
-//        globalRegion,
-//        coupledRegionToMaster,
-//        cellWeights,
-//
-//        globalToLocalRegion,
-//        localPoints,
-//        localWeights
-//    );
-//
-//
-//
-//    // Find distribution for regions
-//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-//    labelList regionDistribution;
-//
-//    if (isA<geomDecomp>(decomposer))
-//    {
-//        regionDistribution = decomposer.decompose(localPoints, localWeights);
-//    }
-//    else
-//    {
-//        labelListList regionRegions;
-//        calcRegionRegions
-//        (
-//            globalRegion,
-//            globalToLocalRegion,
-//            coupledRegionToMaster,
-//
-//            regionRegions
-//        );
-//
-//        regionDistribution = decomposer.decompose
-//        (
-//            regionRegions,
-//            localPoints,
-//            localWeights
-//        );
-//    }
-//
-//
-//
-//    // Convert region-based decomposition back to cell-based one
-//    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-//    // Transfer destination processor back to all. Use global reduce for now.
-//    Map<label> regionToDist(coupledRegionToMaster.size());
-//    forAllConstIter(Map<label>, coupledRegionToMaster, iter)
-//    {
-//        label region = iter.key();
-//
-//        Map<label>::const_iterator regionFnd = globalToLocalRegion.find
-//        (region);
-//
-//        if (regionFnd != globalToLocalRegion.end())
-//        {
-//            // Master cell is local. Store my distribution.
-//            regionToDist.insert(iter.key(), regionDistribution[regionFnd()]);
-//        }
-//        else
-//        {
-//            // Master cell is not on this processor. Make sure it is
-//            // overridden.
-//            regionToDist.insert(iter.key(), labelMax);
-//        }
-//    }
-//    Pstream::mapCombineGather(regionToDist, minEqOp<label>());
-//    Pstream::mapCombineScatter(regionToDist);
-//
-//
-//    // Determine destination for all cells
-//    labelList distribution(mesh_.nCells());
-//
-//    forAll(globalRegion, cellI)
-//    {
-//        Map<label>::const_iterator fndRegion =
-//            regionToDist.find(globalRegion[cellI]);
-//
-//        if (fndRegion != regionToDist.end())
-//        {
-//            distribution[cellI] = fndRegion();
-//        }
-//        else
-//        {
-//            // region is local to the processor.
-//            label localRegionI = globalToLocalRegion[globalRegion[cellI]];
-//
-//            distribution[cellI] = regionDistribution[localRegionI];
-//        }
-//    }
-//
-//    return distribution;
-//}
-
-
 Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
 (
     const bool keepZoneFaces,
@@ -1432,37 +1289,29 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
                 // keep owner&neighbour of such a surface zone on the same
                 // processor.
 
-                const PtrList<surfaceZonesInfo>& surfZones =
-                    surfaces().surfZones();
                 const faceZoneMesh& fZones = mesh_.faceZones();
                 const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
 
                 // Get faces whose owner and neighbour should stay together,
                 // i.e. they are not 'blocked'.
 
-                forAll(surfZones, surfI)
+                forAll(fZones, zoneI)
                 {
-                    const word& fzName = surfZones[surfI].faceZoneName();
+                    const faceZone& fZone = fZones[zoneI];
 
-                    if (fzName.size())
+                    forAll(fZone, i)
                     {
-                        // Get zone
-                        const faceZone& fZone = fZones[fzName];
-
-                        forAll(fZone, i)
+                        label faceI = fZone[i];
+                        if (blockedFace[faceI])
                         {
-                            label faceI = fZone[i];
-                            if (blockedFace[faceI])
+                            if
+                            (
+                                mesh_.isInternalFace(faceI)
+                             || pbm[pbm.whichPatch(faceI)].coupled()
+                            )
                             {
-                                if
-                                (
-                                    mesh_.isInternalFace(faceI)
-                                 || pbm[pbm.whichPatch(faceI)].coupled()
-                                )
-                                {
-                                    blockedFace[faceI] = false;
-                                    nUnblocked++;
-                                }
+                                blockedFace[faceI] = false;
+                                nUnblocked++;
                             }
                         }
                     }
@@ -1559,52 +1408,7 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
                 Info<< "Found " << nCouples << " baffles to keep together."
                     << endl;
             }
-
-            //if (nUnblocked > 0 || nCouples > 0)
-            //{
-            //    Info<< "Applying special decomposition to keep baffles"
-            //        << " and zoned faces together." << endl;
-            //
-            //    distribution = decomposeCombineRegions
-            //    (
-            //        cellWeights,
-            //        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_,
-            //        mesh_.cellCentres(),
-            //        cellWeights
-            //    );
-            //}
         }
-        //else
-        //{
-        //    // Normal decomposition
-        //    distribution = decomposer.decompose
-        //    (
-        //        mesh_,
-        //        cellWeights
-        //    );
-        //}
 
 
         // Make sure blockedFace not set on couples
@@ -1639,7 +1443,36 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
                 Pout<< "    " << procI << '\t' << nProcCells[procI] << endl;
             }
             Pout<< endl;
+
+
+            if (keepZoneFaces)
+            {
+                const faceZoneMesh& fZones = mesh_.faceZones();
+                const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
+                // Check that faceZone faces are indeed internal
+                forAll(fZones, zoneI)
+                {
+                    const faceZone& fZone = fZones[zoneI];
+
+                    forAll(fZone, i)
+                    {
+                        label faceI = fZone[i];
+                        label patchI = pbm.whichPatch(faceI);
+
+                        if (patchI >= 0 && pbm[patchI].coupled())
+                        {
+                            WarningIn("meshRefinement::balance(..)")
+                                << "Face at " << mesh_.faceCentres()[faceI]
+                                << " on zone " << fZone.name()
+                                << " is on coupled patch " << pbm[patchI].name()
+                                << endl;
+                        }
+                    }
+                }
+            }
         }
+
         // Do actual sending/receiving of mesh
         map = distributor.distribute(distribution);
 
@@ -2259,6 +2092,59 @@ Foam::labelList Foam::meshRefinement::meshedPatches() const
 }
 
 
+Foam::label Foam::meshRefinement::addFaceZone
+(
+    const word& fzName,
+    const word& masterPatch,
+    const word& slavePatch,
+    const surfaceZonesInfo::faceZoneType& fzType
+)
+{
+    label zoneI = surfaceZonesInfo::addFaceZone
+    (
+        fzName,   //name
+        labelList(0),   //addressing
+        boolList(0),    //flipmap
+        mesh_
+    );
+
+    faceZoneToMasterPatch_.insert(fzName, masterPatch);
+    faceZoneToSlavePatch_.insert(fzName, slavePatch);
+    faceZoneToType_.insert(fzName, fzType);
+
+    return zoneI;
+}
+
+
+bool Foam::meshRefinement::getFaceZoneInfo
+(
+    const word& fzName,
+    label& masterPatchID,
+    label& slavePatchID,
+    surfaceZonesInfo::faceZoneType& fzType
+) const
+{
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
+    if (!faceZoneToMasterPatch_.found(fzName))
+    {
+        return false;
+    }
+    else
+    {
+        const word& masterName = faceZoneToMasterPatch_[fzName];
+        masterPatchID = pbm.findPatchID(masterName);
+
+        const word& slaveName = faceZoneToSlavePatch_[fzName];
+        slavePatchID = pbm.findPatchID(slaveName);
+
+        fzType = faceZoneToType_[fzName];
+
+        return true;
+    }
+}
+
+
 void Foam::meshRefinement::selectSeparatedCoupledFaces(boolList& selected) const
 {
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
@@ -2295,6 +2181,17 @@ Foam::label Foam::meshRefinement::findRegion
 {
     label regionI = -1;
     label cellI = mesh.findCell(p);
+    //if (cellI != -1)
+    //{
+    //    Pout<< "findRegion : Found point:" << p << " in cell " << cellI
+    //        << " at:" << mesh.cellCentres()[cellI] << endl;
+    //}
+    //else
+    //{
+    //    Pout<< "findRegion : Found point:" << p << " in cell " << cellI
+    //        << endl;
+    //}
+
     if (cellI != -1)
     {
         regionI = cellToRegion[cellI];
@@ -2313,13 +2210,152 @@ Foam::label Foam::meshRefinement::findRegion
     }
     return regionI;
 }
+//XXXXXXXX
+//Foam::labelList Foam::meshRefinement::findRegion
+//(
+//    const polyMesh& mesh,
+//    const labelList& cellToRegion,
+//    const vector& perturbVec,
+//    const pointField& pts
+//)
+//{
+//    labelList regions(pts.size(), -1);
+//
+//    forAll(pts, i)
+//    {
+//        label cellI = mesh.findCell(pts[i]);
+//        if (cellI != -1)
+//        {
+//            regions[i] = cellToRegion[cellI];
+//        }
+//        reduce(regions[i], maxOp<label>());
+//
+//        if (regions[i] == -1)
+//        {
+//            // See if we can perturb a bit
+//            cellI = mesh.findCell(pts[i]+perturbVec);
+//            if (cellI != -1)
+//            {
+//                regions[i] = cellToRegion[cellI];
+//            }
+//            reduce(regions[i], maxOp<label>());
+//        }
+//    }
+//
+//    forAll(regions, i)
+//    {
+//        if (regions[i] == -1)
+//        {
+//            FatalErrorIn
+//            (
+//                "meshRefinement::findRegion"
+//                "(const polyMesh&, const labelList&, const vector&"
+//                  ", const pointField&)"
+//            )   << "Point " << pts[i]
+//                << " is not inside the mesh." << nl
+//                << "Bounding box of the mesh:" << mesh.bounds()
+//                //<< "All points " << pts
+//                //<< " with corresponding regions " << regions
+//                << exit(FatalError);
+//        }
+//    }
+//
+//    return regions;
+//}
+//XXXXXXXX
+
+
+// Modify cellRegion to be consistent with locationsInMesh.
+// - all regions not in locationsInMesh are set to -1
+// - check that all regions inside locationsOutsideMesh are set to -1
+void Foam::meshRefinement::findRegions
+(
+    const polyMesh& mesh,
+    const vector& perturbVec,
+    const pointField& locationsInMesh,
+    const pointField& locationsOutsideMesh,
+    const label nRegions,
+    labelList& cellRegion
+)
+{
+    PackedBoolList insideCell(mesh.nCells());
+
+
+    // Mark all cells reachable from locationsInMesh
+    labelList insideRegions(locationsInMesh.size());
+    forAll(insideRegions, i)
+    {
+        // Find the region containing the point
+        label regionI = findRegion
+        (
+            mesh,
+            cellRegion,
+            perturbVec,
+            locationsInMesh[i]
+        );
+
+        insideRegions[i] = regionI;
+
+        // Mark all cells in the region as being inside
+        forAll(cellRegion, cellI)
+        {
+            if (cellRegion[cellI] == regionI)
+            {
+                insideCell[cellI] = true;
+            }
+        }
+    }
+
+
+
+    // Check that all the locations outside the
+    // mesh do not conflict with those inside
+    forAll(locationsOutsideMesh, i)
+    {
+        // Find the region containing the point
+        label regionI = findRegion
+        (
+            mesh,
+            cellRegion,
+            perturbVec,
+            locationsOutsideMesh[i]
+        );
+
+        if (regionI != -1)
+        {
+            // Do a quick check for locationsOutsideMesh overlapping with
+            // inside ones.
+            label index = findIndex(insideRegions, regionI);
+            if (index != -1)
+            {
+                FatalErrorIn("meshRefinement::findRegions(..)")
+                    << "Location in mesh " << locationsInMesh[index]
+                    << " is inside same mesh region " << regionI
+                    << " as location outside mesh "
+                    << locationsOutsideMesh[i]
+                    << exit(FatalError);
+            }
+        }
+    }
+
+
+    // Now update cellRegion to -1 for unreachable cells
+    forAll(insideCell, cellI)
+    {
+        if (!insideCell[cellI])
+        {
+            cellRegion[cellI] = -1;
+        }
+    }
+}
 
 
 Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMeshRegions
 (
     const labelList& globalToMasterPatch,
     const labelList& globalToSlavePatch,
-    const point& keepPoint
+    const pointField& locationsInMesh,
+    const pointField& locationsOutsideMesh
 )
 {
     // Force calculation of face decomposition (used in findCell)
@@ -2333,25 +2369,16 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMeshRegions
 
     regionSplit cellRegion(mesh_, blockedFace);
 
-    label regionI = findRegion
+    findRegions
     (
         mesh_,
-        cellRegion,
-        mergeDistance_*vector(1,1,1), // note:1,1,1 should really be normalised
-        keepPoint
+        mergeDistance_*vector(1,1,1),   // perturbVec
+        locationsInMesh,
+        locationsOutsideMesh,
+        cellRegion.nRegions(),
+        cellRegion
     );
 
-    if (regionI == -1)
-    {
-        FatalErrorIn
-        (
-            "meshRefinement::splitMeshRegions(const point&)"
-        )   << "Point " << keepPoint
-            << " is not inside the mesh." << nl
-            << "Bounding box of the mesh:" << mesh_.bounds()
-            << exit(FatalError);
-    }
-
     // Subset
     // ~~~~~~
 
@@ -2359,7 +2386,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMeshRegions
     DynamicList<label> cellsToRemove(mesh_.nCells());
     forAll(cellRegion, cellI)
     {
-        if (cellRegion[cellI] != regionI)
+        if (cellRegion[cellI] == -1)
         {
             cellsToRemove.append(cellI);
         }
@@ -2369,8 +2396,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMeshRegions
     label nCellsToKeep = mesh_.nCells() - cellsToRemove.size();
     reduce(nCellsToKeep, sumOp<label>());
 
-    Info<< "Keeping all cells in region " << regionI
-        << " containing point " << keepPoint << endl
+    Info<< "Keeping all cells containing points " << locationsInMesh << endl
         << "Selected for keeping : "
         << nCellsToKeep
         << " cells." << endl;
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
index 78b7d9a1a1..7ae5d5ac29 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H
@@ -51,6 +51,8 @@ SourceFiles
 #include "pointFieldsFwd.H"
 #include "Tuple2.H"
 #include "pointIndexHit.H"
+#include "wordPairHashTable.H"
+#include "surfaceZonesInfo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -74,6 +76,7 @@ class localPointRegion;
 
 class snapParameters;
 
+
 /*---------------------------------------------------------------------------*\
                            Class meshRefinement Declaration
 \*---------------------------------------------------------------------------*/
@@ -190,6 +193,15 @@ private:
         //  order changes.
         wordList meshedPatches_;
 
+        //- FaceZone to master patch name
+        HashTable<word, word> faceZoneToMasterPatch_;
+
+        //- FaceZone to slave patch name
+        HashTable<word, word> faceZoneToSlavePatch_;
+
+        //- FaceZone to method to handle faces
+        HashTable<surfaceZonesInfo::faceZoneType, word> faceZoneToType_;
+
 
     // Private Member Functions
 
@@ -216,9 +228,6 @@ private:
             pointField& neiCc
         ) const;
 
-        //- Find any intersection of surface. Store in surfaceIndex_.
-        void updateIntersections(const labelList& changedFaces);
-
         //- Remove cells. Put exposedFaces into exposedPatchIDs.
         autoPtr<mapPolyMesh> doRemoveCells
         (
@@ -369,10 +378,25 @@ private:
                 const labelList& globalToSlavePatch
             ) const;
 
+            //- Calculate intersections. Return per face -1 or the global
+            //  surface region
+            void getIntersections
+            (
+                const labelList& surfacesToTest,
+                const pointField& neiCc,
+                const labelList& testFaces,
+
+                labelList& globalRegion1,
+                labelList& globalRegion2
+            ) const;
+
             //- Determine patches for baffles
             void getBafflePatches
             (
                 const labelList& globalToMasterPatch,
+                const pointField& locationsInMesh,
+                const wordList& regionsInMesh,
+
                 const labelList& neiLevel,
                 const pointField& neiCc,
                 labelList& ownPatch,
@@ -494,6 +518,16 @@ private:
                 labelList& cellToZone
             ) const;
 
+            //- Finds zone per cell for cells inside region for which name
+            //  is specified.
+            void findCellZoneInsideWalk
+            (
+                const pointField& locationsInMesh,
+                const wordList& regionsInMesh,
+                const labelList& blockedFace, // per face -1 or some index >= 0
+                labelList& cellToZone
+            ) const;
+
             //- Determines cell zone from cell region information.
             bool calcRegionToZone
             (
@@ -508,7 +542,7 @@ private:
             //  marked in namedSurfaceIndex regarded as blocked.
             void findCellZoneTopo
             (
-                const point& keepPoint,
+                const pointField& locationsInMesh,
                 const labelList& namedSurfaceIndex,
                 const labelList& surfaceToCellZone,
                 labelList& cellToZone
@@ -520,6 +554,26 @@ private:
                 labelList& namedSurfaceIndex
             ) const;
 
+            //- Put cells into cellZone, faces into faceZone
+            void zonify
+            (
+                const PackedBoolList& isMasterFace,
+                const labelList& cellToZone,
+                const labelList& neiCellZone,
+                const labelList& faceToZone,
+                const boolList& meshFlipMap,
+                polyTopoChange& meshMod
+            ) const;
+
+            //- Allocate faceZoneName
+            void allocateInterRegionFaceZone
+            (
+                const label ownZone,
+                const label neiZone,
+                wordPairHashTable& zonesToFaceZone,
+                HashTable<word, labelPair, typename labelPair::Hash<> >&
+            ) const;
+
             //- Remove any loose standing cells
             void handleSnapProblems
             (
@@ -840,7 +894,9 @@ public:
                 Time& runTime,
                 const labelList& globalToMasterPatch,
                 const labelList& globalToSlavePatch,
-                const point& keepPoint
+                const pointField& locationsInMesh,
+                const wordList& regionsInMesh,
+                const pointField& locationsOutsideMesh
             );
 
             //- Split off (with optional buffer layers) unreachable areas
@@ -850,7 +906,10 @@ public:
                 const label nBufferLayers,
                 const labelList& globalToMasterPatch,
                 const labelList& globalToSlavePatch,
-                const point& keepPoint
+
+                const pointField& locationsInMesh,
+                const wordList& regionsInMesh,
+                const pointField& locationsOutsideMesh
             );
 
             //- Find boundary points that connect to more than one cell
@@ -861,6 +920,16 @@ public:
             //  region and split them.
             autoPtr<mapPolyMesh> dupNonManifoldPoints();
 
+            //- Find boundary points that are on faceZones of type boundary
+            //  and duplicate them
+            autoPtr<mapPolyMesh> dupNonManifoldBoundaryPoints();
+
+            //- Merge duplicate points
+            autoPtr<mapPolyMesh> mergePoints
+            (
+                const labelList& pointToDuplicate
+            );
+
             //- Create baffle for every internal face where ownPatch != -1.
             //  External faces get repatched according to ownPatch (neiPatch
             //  should be -1 for these)
@@ -870,25 +939,50 @@ public:
                 const labelList& neiPatch
             );
 
-            //- Create baffles for faces straddling zoned surfaces. Return
-            //  baffles.
-            autoPtr<mapPolyMesh> createZoneBaffles
+            //- Get zones of given type
+            labelList getZones
             (
-                const labelList& globalToMasterPatch,
-                const labelList& globalToSlavePatch,
-                List<labelPair>&
+                const List<surfaceZonesInfo::faceZoneType>& fzTypes
+            ) const;
+
+            //- Subset baffles according to zones
+            static List<labelPair> subsetBaffles
+            (
+                const polyMesh& mesh,
+                const labelList& zoneIDs,
+                const List<labelPair>& baffles
             );
 
-            //- Merge baffles. Gets pairs of faces.
+            //- Create baffles for faces on faceZones. Return created baffles
+            //  (= pairs of faces) and corresponding faceZone
+            autoPtr<mapPolyMesh> createZoneBaffles
+            (
+                const labelList& zoneIDs,
+                List<labelPair>& baffles,
+                labelList& originatingFaceZone
+            );
+
+            //- Merge baffles. Gets pairs of faces
             autoPtr<mapPolyMesh> mergeBaffles(const List<labelPair>&);
 
+            //- Merge all baffles on faceZones
+            autoPtr<mapPolyMesh> mergeZoneBaffles
+            (
+                const bool doInternalZones,
+                const bool doBaffleZones
+            );
+
             //- Put faces/cells into zones according to surface specification.
-            //  Returns null if no zone surfaces present. Region containing
-            //  the keepPoint will not be put into a cellZone.
+            //  Returns null if no zone surfaces present. Regions containing
+            //  locationsInMesh/regionsInMesh will be put in corresponding
+            //  cellZone. keepPoints is for backwards compatibility and sets
+            //  all yet unassigned cells to be non-zoned (zone = -1)
             autoPtr<mapPolyMesh> zonify
             (
-                const point& keepPoint,
-                const bool allowFreeStandingZoneFaces
+                const bool allowFreeStandingZoneFaces,
+                const pointField& locationsInMesh,
+                const wordList& regionsInMesh,
+                wordPairHashTable& zonesToFaceZone
             );
 
 
@@ -913,9 +1007,32 @@ public:
             //- Get patchIDs for patches added in addMeshedPatch.
             labelList meshedPatches() const;
 
+            //- Add/lookup faceZone and update information. Return index of
+            //  faceZone
+            label addFaceZone
+            (
+                const word& fzName,
+                const word& masterPatch,
+                const word& slavePatch,
+                const surfaceZonesInfo::faceZoneType& fzType
+            );
+
+            //- Lookup faceZone information. Return false if no information
+            //  for faceZone
+            bool getFaceZoneInfo
+            (
+                const word& fzName,
+                label& masterPatchID,
+                label& slavePatchID,
+                surfaceZonesInfo::faceZoneType& fzType
+            ) const;
+
             //- Select coupled faces that are not collocated
             void selectSeparatedCoupledFaces(boolList&) const;
 
+            //- Find any intersection of surface. Store in surfaceIndex_.
+            void updateIntersections(const labelList& changedFaces);
+
             //- Find region point is in. Uses optional perturbation to re-test.
             static label findRegion
             (
@@ -925,19 +1042,43 @@ public:
                 const point& p
             );
 
+            static void findRegions
+            (
+                const polyMesh&,
+                const vector& perturbVec,
+                const pointField& locationsInMesh,
+                const pointField& locationsOutsideMesh,
+                const label nRegions,
+                labelList& cellRegion
+            );
+
             //- Split mesh. Keep part containing point.
             autoPtr<mapPolyMesh> splitMeshRegions
             (
                 const labelList& globalToMasterPatch,
                 const labelList& globalToSlavePatch,
-                const point& keepPoint
+                const pointField& locationsInMesh,
+                const pointField& locationsOutsideMesh
             );
 
             //- Split faces into two
-            autoPtr<mapPolyMesh> splitFaces
+            void doSplitFaces
             (
                 const labelList& splitFaces,
-                const labelPairList& splits
+                const labelPairList& splits,
+                polyTopoChange& meshMod
+            ) const;
+
+            //- Split faces along diagonal. Maintain mesh quality. Return
+            //  total number of faces split.
+            label splitFacesUndo
+            (
+                const labelList& splitFaces,
+                const labelPairList& splits,
+                const dictionary& motionDict,
+
+                labelList& duplicateFace,
+                List<labelPair>& baffles
             );
 
             //- Update local numbering for mesh redistribution
@@ -985,6 +1126,16 @@ public:
 
             // Merging coplanar faces and edges
 
+                //- Merge coplanar faces if sets are of size mergeSize
+                //  (usually 4)
+                label mergePatchFaces
+                (
+                    const scalar minCos,
+                    const scalar concaveCos,
+                    const label mergeSize,
+                    const labelList& patchIDs
+                );
+
                 //- Merge coplanar faces. preserveFaces is != -1 for faces
                 //  to be preserved
                 label mergePatchFacesUndo
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
index 76bb6150ef..ed2725ba69 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -40,7 +40,6 @@ License
 #include "polyAddPoint.H"
 #include "localPointRegion.H"
 #include "duplicatePoints.H"
-#include "OFstream.H"
 #include "regionSplit.H"
 #include "removeCells.H"
 #include "unitConversion.H"
@@ -48,6 +47,9 @@ License
 #include "patchFaceOrientation.H"
 #include "PatchEdgeFaceWave.H"
 #include "patchEdgeFaceRegion.H"
+#include "polyMeshAdder.H"
+#include "IOmanip.H"
+#include "refinementParameters.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -170,52 +172,41 @@ Foam::label Foam::meshRefinement::createBaffle
 //}
 
 
-// Determine patches for baffles on all intersected unnamed faces
-void Foam::meshRefinement::getBafflePatches
+void Foam::meshRefinement::getIntersections
 (
-    const labelList& globalToMasterPatch,
-    const labelList& neiLevel,
+    const labelList& surfacesToTest,
     const pointField& neiCc,
+    const labelList& testFaces,
 
-    labelList& ownPatch,
-    labelList& neiPatch
+    labelList& globalRegion1,
+    labelList& globalRegion2
 ) const
 {
-    autoPtr<OFstream> str;
-    label vertI = 0;
+    autoPtr<OBJstream> str;
     if (debug&OBJINTERSECTIONS)
     {
+        mkDir(mesh_.time().path()/timeName());
         str.reset
         (
-            new OFstream
+            new OBJstream
             (
                 mesh_.time().path()/timeName()/"intersections.obj"
             )
         );
 
-        Pout<< "getBafflePatches : Writing surface intersections to file "
+        Pout<< "getIntersections : Writing surface intersections to file "
             << str().name() << nl << endl;
     }
 
     const pointField& cellCentres = mesh_.cellCentres();
 
-    // Surfaces that need to be baffled
-    const labelList surfacesToBaffle
-    (
-        surfaceZonesInfo::getUnnamedSurfaces(surfaces_.surfZones())
-    );
 
-    ownPatch.setSize(mesh_.nFaces());
-    ownPatch = -1;
-    neiPatch.setSize(mesh_.nFaces());
-    neiPatch = -1;
+    globalRegion1.setSize(mesh_.nFaces());
+    globalRegion1 = -1;
+    globalRegion2.setSize(mesh_.nFaces());
+    globalRegion2 = -1;
 
 
-    // Collect candidate faces
-    // ~~~~~~~~~~~~~~~~~~~~~~~
-
-    labelList testFaces(intersectedFaces());
-
     // Collect segments
     // ~~~~~~~~~~~~~~~~
 
@@ -258,7 +249,7 @@ void Foam::meshRefinement::getBafflePatches
     labelList region2;
     surfaces_.findNearestIntersection
     (
-        surfacesToBaffle,
+        surfacesToTest,
         start,
         end,
 
@@ -271,6 +262,7 @@ void Foam::meshRefinement::getBafflePatches
         region2
     );
 
+
     forAll(testFaces, i)
     {
         label faceI = testFaces[i];
@@ -279,36 +271,172 @@ void Foam::meshRefinement::getBafflePatches
         {
             if (str.valid())
             {
-                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;
+                str().write(linePointRef(start[i], hit1[i].rawPoint()));
+                str().write
+                (
+                    linePointRef(hit1[i].rawPoint(), hit2[i].rawPoint())
+                );
+                str().write(linePointRef(hit2[i].rawPoint(), end[i]));
             }
 
             // Pick up the patches
-            ownPatch[faceI] = globalToMasterPatch
-            [
-                surfaces_.globalRegion(surface1[i], region1[i])
-            ];
-            neiPatch[faceI] = globalToMasterPatch
-            [
-                surfaces_.globalRegion(surface2[i], region2[i])
-            ];
+            globalRegion1[faceI] =
+                surfaces_.globalRegion(surface1[i], region1[i]);
+            globalRegion2[faceI] =
+                surfaces_.globalRegion(surface2[i], region2[i]);
 
-            if (ownPatch[faceI] == -1 || neiPatch[faceI] == -1)
+            if (globalRegion1[faceI] == -1 || globalRegion2[faceI] == -1)
             {
-                FatalErrorIn("getBafflePatches(..)")
+                FatalErrorIn("getIntersections(..)")
                     << "problem." << abort(FatalError);
             }
         }
     }
+}
+
+
+// Determine patches for baffles on all intersected unnamed faces
+void Foam::meshRefinement::getBafflePatches
+(
+    const labelList& globalToMasterPatch,
+    const pointField& locationsInMesh,
+    const wordList& zonesInMesh,
+
+    const labelList& neiLevel,
+    const pointField& neiCc,
+
+    labelList& ownPatch,
+    labelList& neiPatch
+) const
+{
+    // Check all unnamed surfaces
+
+    {
+        const labelList testFaces(intersectedFaces());
+
+        labelList globalRegion1;
+        labelList globalRegion2;
+        getIntersections
+        (
+            surfaceZonesInfo::getUnnamedSurfaces(surfaces_.surfZones()),
+            neiCc,
+            testFaces,     // testFaces
+            globalRegion1,
+            globalRegion2
+        );
+
+        ownPatch.setSize(mesh_.nFaces());
+        ownPatch = -1;
+        neiPatch.setSize(mesh_.nFaces());
+        neiPatch = -1;
+        forAll(testFaces, i)
+        {
+            label faceI = testFaces[i];
+            if (globalRegion1[faceI] != -1)
+            {
+                ownPatch[faceI] = globalToMasterPatch[globalRegion1[faceI]];
+            }
+            if (globalRegion2[faceI] != -1)
+            {
+                neiPatch[faceI] = globalToMasterPatch[globalRegion2[faceI]];
+            }
+        }
+    }
+
+
+    if (locationsInMesh.size() > 1)
+    {
+        // Now we need to filter out any possible intersections between
+        // multiple regions. Only the faces on the outside of all
+        // regions are candidates for baffling.
+        // For this we need to go to per-cell information
+
+        labelList cellToZone(mesh_.nCells(), -2);
+
+
+        // Closed surfaces with cellZone specified.
+        const labelList closedNamedSurfaces
+        (
+            surfaceZonesInfo::getClosedNamedSurfaces
+            (
+                surfaces_.surfZones(),
+                surfaces_.geometry(),
+                surfaces_.surfaces()
+            )
+        );
+
+        if (closedNamedSurfaces.size())
+        {
+            Info<< "Found " << closedNamedSurfaces.size()
+                << " closed, named surfaces. Assigning cells in/outside"
+                << " these surfaces to the corresponding cellZone."
+                << nl << endl;
+
+            findCellZoneGeometric
+            (
+                neiCc,
+                closedNamedSurfaces,    // indices of closed surfaces
+                ownPatch,               // per face patch
+                labelList(mesh_.boundaryMesh().size(), 0),// cellZone per patch
+
+                cellToZone
+            );
+        }
+
+        // Locations in mesh - walk
+        findCellZoneInsideWalk
+        (
+            locationsInMesh,
+            zonesInMesh,
+            ownPatch,   // per face -1 or some index >= 0
+            cellToZone
+        );
+
+
+        // Now we will still have some -2 in cellToZone on parts that
+        // are unreachable from the locationsInMesh or named surfaces. We only
+        // want to keep the interfaces to these cellZones.
+
+
+        labelList neiCellZone;
+        syncTools::swapBoundaryCellList(mesh_, cellToZone, neiCellZone);
+
+        // Only keep baffles where one of the sides has an unset cellToZone (-2)
+        for (label faceI=0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            if (ownPatch[faceI] != -1 || neiPatch[faceI] != -1)
+            {
+                label ownZone = cellToZone[mesh_.faceOwner()[faceI]];
+                label neiZone = cellToZone[mesh_.faceNeighbour()[faceI]];
+
+                if (ownZone != -2 && neiZone != -2)
+                {
+                    ownPatch[faceI] = -1;
+                    neiPatch[faceI] = -1;
+                }
+            }
+        }
+        for
+        (
+            label faceI = mesh_.nInternalFaces();
+            faceI < mesh_.nFaces();
+            faceI++
+        )
+        {
+            if (ownPatch[faceI] != -1 || neiPatch[faceI] != -1)
+            {
+                label ownZone = cellToZone[mesh_.faceOwner()[faceI]];
+                label neiZone = neiCellZone[faceI-mesh_.nInternalFaces()];
+
+                if (ownZone != -2 && neiZone != -2)
+                {
+                    ownPatch[faceI] = -1;
+                    neiPatch[faceI] = -1;
+                }
+            }
+        }
+    }
+
 
     // No need to parallel sync since intersection data (surfaceIndex_ etc.)
     // already guaranteed to be synced...
@@ -465,153 +593,277 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createBaffles
         }
     }
 
-    // Change the mesh (no inflation, parallel sync)
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields
-    mesh_.updateMesh(map);
-
-    // Move mesh if in inflation mode
-    if (map().hasMotionPoints())
+    autoPtr<mapPolyMesh> map;
+    if (returnReduce(nBaffles, sumOp<label>()))
     {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-    else
-    {
-        // Delete mesh volumes.
-        mesh_.clearOut();
-    }
+        // Change the mesh (no inflation, parallel sync)
+        map = meshMod.changeMesh(mesh_, false, true);
 
+        // Update fields
+        mesh_.updateMesh(map);
 
-    // Reset the instance for if in overwrite mode
-    mesh_.setInstance(timeName());
-
-    //- Redo the intersections on the newly create baffle faces. Note that
-    //  this changes also the cell centre positions.
-    faceSet baffledFacesSet(mesh_, "baffledFacesSet", 2*nBaffles);
-
-    const labelList& reverseFaceMap = map().reverseFaceMap();
-    const labelList& faceMap = map().faceMap();
-
-    // Pick up owner side of baffle
-    forAll(ownPatch, oldFaceI)
-    {
-        label faceI = reverseFaceMap[oldFaceI];
-
-        if (ownPatch[oldFaceI] != -1 && faceI >= 0)
+        // Move mesh if in inflation mode
+        if (map().hasMotionPoints())
         {
-            const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes.
+            mesh_.clearOut();
+        }
 
-            forAll(ownFaces, i)
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+
+        //- Redo the intersections on the newly create baffle faces. Note that
+        //  this changes also the cell centre positions.
+        faceSet baffledFacesSet(mesh_, "baffledFacesSet", 2*nBaffles);
+
+        const labelList& reverseFaceMap = map().reverseFaceMap();
+        const labelList& faceMap = map().faceMap();
+
+        // Pick up owner side of baffle
+        forAll(ownPatch, oldFaceI)
+        {
+            label faceI = reverseFaceMap[oldFaceI];
+
+            if (ownPatch[oldFaceI] != -1 && faceI >= 0)
             {
-                baffledFacesSet.insert(ownFaces[i]);
+                const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+                forAll(ownFaces, i)
+                {
+                    baffledFacesSet.insert(ownFaces[i]);
+                }
             }
         }
-    }
-    // Pick up neighbour side of baffle (added faces)
-    forAll(faceMap, faceI)
-    {
-        label oldFaceI = faceMap[faceI];
-
-        if (oldFaceI >= 0 && reverseFaceMap[oldFaceI] != faceI)
+        // Pick up neighbour side of baffle (added faces)
+        forAll(faceMap, faceI)
         {
-            const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+            label oldFaceI = faceMap[faceI];
 
-            forAll(ownFaces, i)
+            if (oldFaceI >= 0 && reverseFaceMap[oldFaceI] != faceI)
             {
-                baffledFacesSet.insert(ownFaces[i]);
+                const cell& ownFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
+
+                forAll(ownFaces, i)
+                {
+                    baffledFacesSet.insert(ownFaces[i]);
+                }
             }
         }
-    }
-    baffledFacesSet.sync(mesh_);
+        baffledFacesSet.sync(mesh_);
 
-    updateMesh(map, baffledFacesSet.toc());
+        updateMesh(map, baffledFacesSet.toc());
+    }
 
     return map;
 }
 
 
-Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
+Foam::labelList Foam::meshRefinement::getZones
 (
-    const labelList& globalToMasterPatch,
-    const labelList& globalToSlavePatch,
-    List<labelPair>& baffles
+    const List<surfaceZonesInfo::faceZoneType>& fzTypes
+) const
+{
+    const faceZoneMesh& faceZones = mesh_.faceZones();
+
+    DynamicList<label> zoneIDs(faceZones.size());
+
+    forAll(faceZones, zoneI)
+    {
+        const faceZone& fZone = faceZones[zoneI];
+
+        label mpI, spI;
+        surfaceZonesInfo::faceZoneType fzType;
+        bool hasInfo = getFaceZoneInfo(fZone.name(), mpI, spI, fzType);
+
+        if (hasInfo && findIndex(fzTypes, fzType) != -1)
+        {
+            zoneIDs.append(zoneI);
+        }
+    }
+    return zoneIDs;
+}
+
+
+// Subset those baffles where both faces are on the same zone
+Foam::List<Foam::labelPair> Foam::meshRefinement::subsetBaffles
+(
+    const polyMesh& mesh,
+    const labelList& zoneIDs,
+    const List<labelPair>& baffles
 )
 {
-    const labelList zonedSurfaces
-    (
-        surfaceZonesInfo::getNamedSurfaces(surfaces_.surfZones())
-    );
+    const faceZoneMesh& faceZones = mesh.faceZones();
 
+    // Mark zone per face
+    labelList faceToZone(mesh.nFaces(), -1);
+
+    forAll(zoneIDs, i)
+    {
+        label zoneID = zoneIDs[i];
+        UIndirectList<label>(faceToZone, faceZones[zoneID]) = zoneID;
+    }
+
+
+    // Subset baffles
+    DynamicList<labelPair> newBaffles(baffles.size());
+    forAll(baffles, i)
+    {
+        const labelPair& p = baffles[i];
+        if (faceToZone[p[0]] != -1 && (faceToZone[p[0]] == faceToZone[p[1]]))
+        {
+            newBaffles.append(p);
+        }
+    }
+
+    return newBaffles;
+}
+
+
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
+(
+    const labelList& zoneIDs,
+    List<labelPair>& baffles,
+    labelList& originatingFaceZone
+)
+{
     autoPtr<mapPolyMesh> map;
 
-    // No need to sync; all processors will have all same zonedSurfaces.
-    if (zonedSurfaces.size())
+    if (zoneIDs.size() > 0)
     {
+        const faceZoneMesh& faceZones = mesh_.faceZones();
+
         // 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<labelPair> faceToPatch
-        (
-            getZoneBafflePatches
-            (
-                false,
-                globalToMasterPatch,
-                globalToSlavePatch
-            )
-        );
+        // Per (internal) face the patch it should go into
+        labelList ownPatch(mesh_.nFaces(), -1);
+        labelList neiPatch(mesh_.nFaces(), -1);
+        labelList faceZoneID(mesh_.nFaces(), -1);
 
-        label nZoneFaces = returnReduce(faceToPatch.size(), sumOp<label>());
-        if (nZoneFaces > 0)
+        labelList nBaffles(zoneIDs.size(), 0);
+
+        forAll(zoneIDs, j)
         {
-            // Convert into labelLists
-            labelList ownPatch(mesh_.nFaces(), -1);
-            labelList neiPatch(mesh_.nFaces(), -1);
-            forAllConstIter(Map<labelPair>, faceToPatch, iter)
+            label zoneI = zoneIDs[j];
+
+            const faceZone& fz = faceZones[zoneI];
+
+            const word& masterName = faceZoneToMasterPatch_[fz.name()];
+            label masterPatchI = mesh_.boundaryMesh().findPatchID(masterName);
+            const word& slaveName = faceZoneToSlavePatch_[fz.name()];
+            label slavePatchI = mesh_.boundaryMesh().findPatchID(slaveName);
+
+            if (masterPatchI == -1 || slavePatchI == -1)
             {
-                ownPatch[iter.key()] = iter().first();
-                neiPatch[iter.key()] = iter().second();
+                FatalErrorIn("meshRefinement::createZoneBaffles(..)")
+                    << "Problem: masterPatchI:" << masterPatchI
+                    << " slavePatchI:" << slavePatchI << exit(FatalError);
             }
 
-            // Create baffles. both sides same patch.
+            forAll(fz, i)
+            {
+                label faceI = fz[i];
+                if (mesh_.isInternalFace(faceI))
+                {
+                    if (fz.flipMap()[i])
+                    {
+                        ownPatch[faceI] = slavePatchI;
+                        neiPatch[faceI] = masterPatchI;
+                    }
+                    else
+                    {
+                        ownPatch[faceI] = masterPatchI;
+                        neiPatch[faceI] = slavePatchI;
+                    }
+                    faceZoneID[faceI] = zoneI;
+
+                    nBaffles[j]++;
+                }
+            }
+        }
+
+        label nLocalBaffles = sum(nBaffles);
+
+
+        label nTotalBaffles = returnReduce(nLocalBaffles, sumOp<label>());
+
+        if (nTotalBaffles > 0)
+        {
+            Pstream::listCombineGather(nBaffles, plusEqOp<label>());
+            Pstream::listCombineScatter(nBaffles);
+
+            Info<< nl
+                << setf(ios_base::left)
+                << setw(30) << "FaceZone"
+                << setw(10) << "FaceType"
+                << setw(10) << "nBaffles"
+                << nl
+                << setw(30) << "--------"
+                << setw(10) << "--------"
+                << setw(10) << "--------"
+                << endl;
+
+            forAll(zoneIDs, j)
+            {
+                label zoneI = zoneIDs[j];
+                const faceZone& fz = faceZones[zoneI];
+
+                label mpI, spI;
+                surfaceZonesInfo::faceZoneType fzType;
+                bool hasInfo = getFaceZoneInfo(fz.name(), mpI, spI, fzType);
+
+                if (hasInfo)
+                {
+                    Info<< setf(ios_base::left)
+                        << setw(30) << fz.name()
+                        << setw(10)
+                        << surfaceZonesInfo::faceZoneTypeNames[fzType]
+                        << setw(10) << nBaffles[j]
+                        << nl;
+                }
+            }
+            Info<< endl;
+
+            // Create baffles.
             map = createBaffles(ownPatch, neiPatch);
 
             // Get pairs of faces created.
             // Just loop over faceMap and store baffle if we encounter a slave
             // face.
 
-            baffles.setSize(faceToPatch.size());
+            baffles.setSize(nLocalBaffles);
+            originatingFaceZone.setSize(nLocalBaffles);
             label baffleI = 0;
 
             const labelList& faceMap = map().faceMap();
             const labelList& reverseFaceMap = map().reverseFaceMap();
 
-            forAll(faceMap, faceI)
+            for
+            (
+                label faceI = mesh_.nInternalFaces();
+                faceI < mesh_.nFaces();
+                faceI++
+            )
             {
                 label oldFaceI = faceMap[faceI];
-
-                // Does face originate from face-to-patch
-                Map<labelPair>::const_iterator iter = faceToPatch.find
-                (
-                    oldFaceI
-                );
-
-                if (iter != faceToPatch.end())
+                label masterFaceI = reverseFaceMap[oldFaceI];
+                if (masterFaceI != faceI && ownPatch[oldFaceI] != -1)
                 {
-                    label masterFaceI = reverseFaceMap[oldFaceI];
-                    if (faceI != masterFaceI)
-                    {
-                        baffles[baffleI++] = labelPair(masterFaceI, faceI);
-                    }
+                    baffles[baffleI] = labelPair(masterFaceI, faceI);
+                    originatingFaceZone[baffleI] = faceZoneID[oldFaceI];
+                    baffleI++;
                 }
             }
 
-            if (baffleI != faceToPatch.size())
+            if (baffleI != baffles.size())
             {
                 FatalErrorIn("meshRefinement::createZoneBaffles(..)")
-                    << "Had " << faceToPatch.size() << " patches to create "
+                    << "Had " << baffles.size() << " baffles to create "
                     << " but encountered " << baffleI
                     << " slave faces originating from patcheable faces."
                     << abort(FatalError);
@@ -630,9 +882,15 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
                 );
             }
         }
-        Info<< "Created " << nZoneFaces << " baffles in = "
+        Info<< "Created " << nTotalBaffles << " baffles in = "
             << mesh_.time().cpuTimeIncrement() << " s\n" << nl << endl;
     }
+    else
+    {
+        baffles.clear();
+        originatingFaceZone.clear();
+    }
+
     return map;
 }
 
@@ -902,132 +1160,177 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeBaffles
     const List<labelPair>& couples
 )
 {
-    // Mesh change engine
-    polyTopoChange meshMod(mesh_);
+    autoPtr<mapPolyMesh> map;
 
-    const faceList& faces = mesh_.faces();
-    const labelList& faceOwner = mesh_.faceOwner();
-    const faceZoneMesh& faceZones = mesh_.faceZones();
-
-    forAll(couples, i)
+    if (returnReduce(couples.size(), sumOp<label>()))
     {
-        label face0 = couples[i].first();
-        label face1 = couples[i].second();
+        // Mesh change engine
+        polyTopoChange meshMod(mesh_);
 
-        // face1 < 0 signals a coupled face that has been converted to baffle.
+        const faceList& faces = mesh_.faces();
+        const labelList& faceOwner = mesh_.faceOwner();
+        const faceZoneMesh& faceZones = mesh_.faceZones();
 
-        label own0 = faceOwner[face0];
-        label own1 = faceOwner[face1];
-
-        if (face1 < 0 || own0 < own1)
+        forAll(couples, i)
         {
-            // Use face0 as the new internal face.
-            label zoneID = faceZones.whichZone(face0);
-            bool zoneFlip = false;
+            label face0 = couples[i].first();
+            label face1 = couples[i].second();
 
-            if (zoneID >= 0)
+            // face1 < 0 signals a coupled face that has been converted to
+            // baffle
+
+            label own0 = faceOwner[face0];
+            label own1 = faceOwner[face1];
+
+            if (face1 < 0 || own0 < own1)
             {
-                const faceZone& fZone = faceZones[zoneID];
-                zoneFlip = fZone.flipMap()[fZone.whichFace(face0)];
-            }
+                // Use face0 as the new internal face.
+                label zoneID = faceZones.whichZone(face0);
+                bool zoneFlip = false;
 
-            label nei = (face1 < 0 ? -1 : own1);
+                if (zoneID >= 0)
+                {
+                    const faceZone& fZone = faceZones[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(face0)];
+                }
 
-            meshMod.setAction(polyRemoveFace(face1));
-            meshMod.setAction
-            (
-                polyModifyFace
+                label nei = (face1 < 0 ? -1 : own1);
+
+                meshMod.setAction(polyRemoveFace(face1));
+                meshMod.setAction
                 (
-                    faces[face0],           // modified face
-                    face0,                  // label of face being modified
-                    own0,                   // owner
-                    nei,                    // neighbour
-                    false,                  // face flip
-                    -1,                     // patch for face
-                    false,                  // remove from zone
-                    zoneID,                 // zone for face
-                    zoneFlip                // face flip in zone
-                )
-            );
+                    polyModifyFace
+                    (
+                        faces[face0],           // modified face
+                        face0,                  // label of face being modified
+                        own0,                   // owner
+                        nei,                    // neighbour
+                        false,                  // face flip
+                        -1,                     // patch for face
+                        false,                  // remove from zone
+                        zoneID,                 // zone for face
+                        zoneFlip                // face flip in zone
+                    )
+                );
+            }
+            else
+            {
+                // Use face1 as the new internal face.
+                label zoneID = faceZones.whichZone(face1);
+                bool zoneFlip = false;
+
+                if (zoneID >= 0)
+                {
+                    const faceZone& fZone = faceZones[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(face1)];
+                }
+
+                meshMod.setAction(polyRemoveFace(face0));
+                meshMod.setAction
+                (
+                    polyModifyFace
+                    (
+                        faces[face1],           // modified face
+                        face1,                  // label of face being modified
+                        own1,                   // owner
+                        own0,                   // neighbour
+                        false,                  // face flip
+                        -1,                     // patch for face
+                        false,                  // remove from zone
+                        zoneID,                 // zone for face
+                        zoneFlip                // face flip in zone
+                    )
+                );
+            }
+        }
+
+        // Change the mesh (no inflation)
+        map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
         }
         else
         {
-            // Use face1 as the new internal face.
-            label zoneID = faceZones.whichZone(face1);
-            bool zoneFlip = false;
+            // Delete mesh volumes.
+            mesh_.clearOut();
+        }
 
-            if (zoneID >= 0)
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+
+        // Update intersections. Recalculate intersections on merged faces since
+        // this seems to give problems? Note: should not be necessary since
+        // baffles preserve intersections from when they were created.
+        labelList newExposedFaces(2*couples.size());
+        label newI = 0;
+
+        forAll(couples, i)
+        {
+            label newFace0 = map().reverseFaceMap()[couples[i].first()];
+            if (newFace0 != -1)
             {
-                const faceZone& fZone = faceZones[zoneID];
-                zoneFlip = fZone.flipMap()[fZone.whichFace(face1)];
+                newExposedFaces[newI++] = newFace0;
             }
 
-            meshMod.setAction(polyRemoveFace(face0));
-            meshMod.setAction
-            (
-                polyModifyFace
-                (
-                    faces[face1],           // modified face
-                    face1,                  // label of face being modified
-                    own1,                   // owner
-                    own0,                   // neighbour
-                    false,                  // face flip
-                    -1,                     // patch for face
-                    false,                  // remove from zone
-                    zoneID,                 // zone for face
-                    zoneFlip                // face flip in zone
-                )
-            );
+            label newFace1 = map().reverseFaceMap()[couples[i].second()];
+            if (newFace1 != -1)
+            {
+                newExposedFaces[newI++] = newFace1;
+            }
         }
+        newExposedFaces.setSize(newI);
+        updateMesh(map, newExposedFaces);
     }
 
-    // Change the mesh (no inflation)
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields
-    mesh_.updateMesh(map);
-
-    // Move mesh (since morphing does not do this)
-    if (map().hasMotionPoints())
-    {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-    else
-    {
-        // Delete mesh volumes.
-        mesh_.clearOut();
-    }
-
-    // Reset the instance for if in overwrite mode
-    mesh_.setInstance(timeName());
-
-    // Update intersections. Recalculate intersections on merged faces since
-    // this seems to give problems? Note: should not be necessary since
-    // baffles preserve intersections from when they were created.
-    labelList newExposedFaces(2*couples.size());
-    label newI = 0;
-
-    forAll(couples, i)
-    {
-        label newFace0 = map().reverseFaceMap()[couples[i].first()];
-        if (newFace0 != -1)
-        {
-            newExposedFaces[newI++] = newFace0;
-        }
-
-        label newFace1 = map().reverseFaceMap()[couples[i].second()];
-        if (newFace1 != -1)
-        {
-            newExposedFaces[newI++] = newFace1;
-        }
-    }
-    newExposedFaces.setSize(newI);
-    updateMesh(map, newExposedFaces);
-
     return map;
 }
 
 
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeZoneBaffles
+(
+    const bool doInternalZones,
+    const bool doBaffleZones
+)
+{
+    labelList zoneIDs;
+    {
+        DynamicList<surfaceZonesInfo::faceZoneType> fzTypes;
+        if (doInternalZones)
+        {
+            fzTypes.append(surfaceZonesInfo::INTERNAL);
+        }
+        if (doBaffleZones)
+        {
+            fzTypes.append(surfaceZonesInfo::BAFFLE);
+        }
+        zoneIDs = getZones(fzTypes);
+    }
+
+    List<labelPair> zoneBaffles
+    (
+        subsetBaffles
+        (
+            mesh_,
+            zoneIDs,
+            localPointRegion::findDuplicateFacePairs(mesh_)
+        )
+    );
+
+    autoPtr<mapPolyMesh> mapPtr;
+    if (returnReduce(zoneBaffles.size(), sumOp<label>()))
+    {
+        mapPtr = mergeBaffles(zoneBaffles);
+    }
+    return mapPtr;
+}
+
+
 // Finds region per cell for cells inside closed named surfaces
 void Foam::meshRefinement::findCellZoneGeometric
 (
@@ -1185,33 +1488,29 @@ void Foam::meshRefinement::findCellZoneGeometric
 
         if (namedSurfaceIndex[faceI] == -1 && (ownZone != neiZone))
         {
-            // Give face the zone of max cell zone
-            namedSurfaceIndex[faceI] = findIndex
-            (
-                surfaceToCellZone,
-                max(ownZone, neiZone)
-            );
-        }
-    }
-
-    labelList neiCellZone(mesh_.nFaces()-mesh_.nInternalFaces());
-    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if (pp.coupled())
-        {
-            forAll(pp, i)
+            // Give face the zone of min cell zone
+            label minZone;
+            if (ownZone == -1)
             {
-                label faceI = pp.start()+i;
-                label ownZone = cellToZone[mesh_.faceOwner()[faceI]];
-                neiCellZone[faceI-mesh_.nInternalFaces()] = ownZone;
+                minZone = neiZone;
             }
+            else if (neiZone == -1)
+            {
+                minZone = ownZone;
+            }
+            else
+            {
+                minZone = min(ownZone, neiZone);
+            }
+
+            namedSurfaceIndex[faceI] = findIndex(surfaceToCellZone, minZone);
         }
     }
-    syncTools::swapBoundaryFaceList(mesh_, neiCellZone);
+
+    labelList neiCellZone;
+    syncTools::swapBoundaryCellList(mesh_, cellToZone, neiCellZone);
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
 
     forAll(patches, patchI)
     {
@@ -1227,11 +1526,25 @@ void Foam::meshRefinement::findCellZoneGeometric
 
                 if (namedSurfaceIndex[faceI] == -1 && (ownZone != neiZone))
                 {
-                    // Give face the max cell zone
+                    // Give face the min cell zone
+                    label minZone;
+                    if (ownZone == -1)
+                    {
+                        minZone = neiZone;
+                    }
+                    else if (neiZone == -1)
+                    {
+                        minZone = ownZone;
+                    }
+                    else
+                    {
+                        minZone = min(ownZone, neiZone);
+                    }
+
                     namedSurfaceIndex[faceI] = findIndex
                     (
                         surfaceToCellZone,
-                        max(ownZone, neiZone)
+                        minZone
                     );
                 }
             }
@@ -1286,10 +1599,6 @@ void Foam::meshRefinement::findCellZoneInsideWalk
 
         const point& insidePoint = surfZones[surfI].zoneInsidePoint();
 
-        Info<< "For surface " << surfaces_.names()[surfI]
-            << " finding inside point " << insidePoint
-            << endl;
-
         // Find the region containing the insidePoint
         label keepRegionI = findRegion
         (
@@ -1348,6 +1657,118 @@ void Foam::meshRefinement::findCellZoneInsideWalk
 }
 
 
+void Foam::meshRefinement::findCellZoneInsideWalk
+(
+    const pointField& locationsInMesh,
+    const wordList& zonesInMesh,
+    const labelList& faceToZone, // per face -1 or some index >= 0
+
+    labelList& cellToZone
+) const
+{
+    // Analyse regions. Reuse regionsplit
+    boolList blockedFace(mesh_.nFaces());
+    //selectSeparatedCoupledFaces(blockedFace);
+
+    forAll(blockedFace, faceI)
+    {
+        if (faceToZone[faceI] == -1)
+        {
+            blockedFace[faceI] = false;
+        }
+        else
+        {
+            blockedFace[faceI] = true;
+        }
+    }
+    // No need to sync since blockedFace already is synced
+
+    // Set region per cell based on walking
+    regionSplit cellRegion(mesh_, blockedFace);
+    blockedFace.clear();
+
+
+    // Force calculation of face decomposition (used in findCell)
+    (void)mesh_.tetBasePtIs();
+
+    // For all locationsInMesh find the cell
+    forAll(locationsInMesh, i)
+    {
+//        const word& czName = zonesInMesh[i];
+//        if (czName != "noneIfNotSet")
+        {
+            // Get location and index of zone ("none" for cellZone -1)
+            const point& insidePoint = locationsInMesh[i];
+            label zoneID = mesh_.cellZones().findZoneID(zonesInMesh[i]);
+
+            // Find the region containing the insidePoint
+            label keepRegionI = findRegion
+            (
+                mesh_,
+                cellRegion,
+                mergeDistance_*vector(1,1,1),
+                insidePoint
+            );
+
+            Info<< "For cellZone " << zonesInMesh[i]
+                << " found point " << insidePoint
+                << " in global region " << keepRegionI
+                << " out of " << cellRegion.nRegions() << " regions." << endl;
+
+            if (keepRegionI == -1)
+            {
+                FatalErrorIn
+                (
+                    "meshRefinement::findCellZoneInsideWalk"
+                    "(const labelList&, const labelList&"
+                    ", const labelList&, const labelList&)"
+                )   << "Point " << insidePoint
+                    << " is not inside the mesh." << nl
+                    << "Bounding box of the mesh:" << mesh_.bounds()
+                    << exit(FatalError);
+            }
+
+            // Set all cells with this region
+            label nWarnings = 0;
+
+            forAll(cellRegion, cellI)
+            {
+                if (cellRegion[cellI] == keepRegionI)
+                {
+                    if (cellToZone[cellI] == -2)
+                    {
+                        // First visit of cell
+                        cellToZone[cellI] = zoneID;
+                    }
+                    else if (cellToZone[cellI] != zoneID)
+                    {
+                        if (nWarnings < 10)
+                        {
+                            WarningIn
+                            (
+                                "meshRefinement::findCellZoneInsideWalk"
+                                "(const labelList&, const labelList&"
+                                ", const labelList&, const labelList&)"
+                            )   << "Cell " << cellI
+                                << " at " << mesh_.cellCentres()[cellI]
+                                << " is inside cellZone " << zonesInMesh[i]
+                                << " from locationInMesh " << insidePoint
+                                << " but already marked as being in zone "
+                                << mesh_.cellZones()[cellToZone[cellI]].name()
+                                << endl
+                                << "This can happen if your surfaces are not"
+                                << " (sufficiently) closed."
+                                << endl;
+                            nWarnings++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
 bool Foam::meshRefinement::calcRegionToZone
 (
     const label surfZoneI,
@@ -1407,12 +1828,12 @@ bool Foam::meshRefinement::calcRegionToZone
 
 
 // Finds region per cell. Assumes:
-// - region containing keepPoint does not go into a cellZone
+// - locationsInMesh go into specified cellZone or non-zone
 // - all other regions can be found by crossing faces marked in
 //   namedSurfaceIndex.
 void Foam::meshRefinement::findCellZoneTopo
 (
-    const point& keepPoint,
+    const pointField& locationsInMesh,
     const labelList& namedSurfaceIndex,
     const labelList& surfaceToCellZone,
     labelList& cellToZone
@@ -1457,34 +1878,39 @@ void Foam::meshRefinement::findCellZoneTopo
 
 
     // Find the region containing the keepPoint
-    label keepRegionI = findRegion
-    (
-        mesh_,
-        cellRegion,
-        mergeDistance_*vector(1,1,1),
-        keepPoint
-    );
-
-    Info<< "Found point " << keepPoint
-        << " in global region " << keepRegionI
-        << " out of " << cellRegion.nRegions() << " regions." << endl;
-
-    if (keepRegionI == -1)
+    forAll(locationsInMesh, i)
     {
-        FatalErrorIn
+        const point& keepPoint = locationsInMesh[i];
+        label keepRegionI = findRegion
         (
-            "meshRefinement::findCellZoneTopo"
-            "(const point&, const labelList&, const labelList&, labelList&)"
-        )   << "Point " << keepPoint
-            << " is not inside the mesh." << nl
-            << "Bounding box of the mesh:" << mesh_.bounds()
-            << exit(FatalError);
-    }
+            mesh_,
+            cellRegion,
+            mergeDistance_*vector(1,1,1),
+            keepPoint
+        );
 
-    // Mark default region with zone -1.
-    if (regionToCellZone[keepRegionI] == -2)
-    {
-        regionToCellZone[keepRegionI] = -1;
+        Info<< "Found point " << keepPoint
+            << " in global region " << keepRegionI
+            << " out of " << cellRegion.nRegions() << " regions." << endl;
+
+        if (keepRegionI == -1)
+        {
+            FatalErrorIn
+            (
+                "meshRefinement::findCellZoneTopo"
+                "(const point&, const labelList&"
+                ", const labelList&, labelList&)"
+            )   << "Point " << keepPoint
+                << " is not inside the mesh." << nl
+                << "Bounding box of the mesh:" << mesh_.bounds()
+                << exit(FatalError);
+        }
+
+        // Mark default region with zone -1.
+        if (regionToCellZone[keepRegionI] == -2)
+        {
+            regionToCellZone[keepRegionI] = -1;
+        }
     }
 
 
@@ -1533,22 +1959,8 @@ void Foam::meshRefinement::findCellZoneTopo
         const polyBoundaryMesh& patches = mesh_.boundaryMesh();
 
         // Get coupled neighbour cellRegion
-        labelList neiCellRegion(mesh_.nFaces()-mesh_.nInternalFaces());
-        forAll(patches, patchI)
-        {
-            const polyPatch& pp = patches[patchI];
-
-            if (pp.coupled())
-            {
-                forAll(pp, i)
-                {
-                    label faceI = pp.start()+i;
-                    neiCellRegion[faceI-mesh_.nInternalFaces()] =
-                        cellRegion[mesh_.faceOwner()[faceI]];
-                }
-            }
-        }
-        syncTools::swapBoundaryFaceList(mesh_, neiCellRegion);
+        labelList neiCellRegion;
+        syncTools::swapBoundaryCellList(mesh_, cellRegion, neiCellRegion);
 
         // Calculate region to zone from cellRegions on either side of coupled
         // face.
@@ -1626,7 +2038,7 @@ void Foam::meshRefinement::findCellZoneTopo
 void Foam::meshRefinement::makeConsistentFaceIndex
 (
     const labelList& cellToZone,
-    labelList& namedSurfaceIndex
+    labelList& faceToZone
 ) const
 {
     const labelList& faceOwner = mesh_.faceOwner();
@@ -1637,11 +2049,11 @@ void Foam::meshRefinement::makeConsistentFaceIndex
         label ownZone = cellToZone[faceOwner[faceI]];
         label neiZone = cellToZone[faceNeighbour[faceI]];
 
-        if (ownZone == neiZone && namedSurfaceIndex[faceI] != -1)
+        if (ownZone == neiZone && faceToZone[faceI] != -1)
         {
-            namedSurfaceIndex[faceI] = -1;
+            faceToZone[faceI] = -1;
         }
-        else if (ownZone != neiZone && namedSurfaceIndex[faceI] == -1)
+        else if (ownZone != neiZone && faceToZone[faceI] == -1)
         {
             FatalErrorIn("meshRefinement::zonify()")
                 << "Different cell zones on either side of face " << faceI
@@ -1654,22 +2066,8 @@ void Foam::meshRefinement::makeConsistentFaceIndex
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();
 
     // Get coupled neighbour cellZone
-    labelList neiCellZone(mesh_.nFaces()-mesh_.nInternalFaces());
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
-
-        if (pp.coupled())
-        {
-            forAll(pp, i)
-            {
-                label faceI = pp.start()+i;
-                neiCellZone[faceI-mesh_.nInternalFaces()] =
-                    cellToZone[mesh_.faceOwner()[faceI]];
-            }
-        }
-    }
-    syncTools::swapBoundaryFaceList(mesh_, neiCellZone);
+    labelList neiCellZone;
+    syncTools::swapBoundaryCellList(mesh_, cellToZone, neiCellZone);
 
     // Use coupled cellZone to do check
     forAll(patches, patchI)
@@ -1685,11 +2083,11 @@ void Foam::meshRefinement::makeConsistentFaceIndex
                 label ownZone = cellToZone[faceOwner[faceI]];
                 label neiZone = neiCellZone[faceI-mesh_.nInternalFaces()];
 
-                if (ownZone == neiZone && namedSurfaceIndex[faceI] != -1)
+                if (ownZone == neiZone && faceToZone[faceI] != -1)
                 {
-                    namedSurfaceIndex[faceI] = -1;
+                    faceToZone[faceI] = -1;
                 }
-                else if (ownZone != neiZone && namedSurfaceIndex[faceI] == -1)
+                else if (ownZone != neiZone && faceToZone[faceI] == -1)
                 {
                     FatalErrorIn("meshRefinement::zonify()")
                         << "Different cell zones on either side of face "
@@ -1705,7 +2103,7 @@ void Foam::meshRefinement::makeConsistentFaceIndex
             forAll(pp, i)
             {
                 label faceI = pp.start()+i;
-                namedSurfaceIndex[faceI] = -1;
+                faceToZone[faceI] = -1;
             }
         }
     }
@@ -1802,7 +2200,7 @@ void Foam::meshRefinement::handleSnapProblems
 
 Foam::labelList Foam::meshRefinement::freeStandingBaffleFaces
 (
-    const labelList& namedSurfaceIndex,
+    const labelList& faceToZone,
     const labelList& cellToZone,
     const labelList& neiCellZone
 ) const
@@ -1816,8 +2214,7 @@ Foam::labelList Foam::meshRefinement::freeStandingBaffleFaces
 
     for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
     {
-        label surfI = namedSurfaceIndex[faceI];
-        if (surfI != -1)
+        if (faceToZone[faceI] != -1)
         {
             // Free standing baffle?
             label ownZone = cellToZone[faceOwner[faceI]];
@@ -1835,8 +2232,7 @@ Foam::labelList Foam::meshRefinement::freeStandingBaffleFaces
         forAll(pp, i)
         {
             label faceI = pp.start()+i;
-            label surfI = namedSurfaceIndex[faceI];
-            if (surfI != -1)
+            if (faceToZone[faceI] != -1)
             {
                 // Free standing baffle?
                 label ownZone = cellToZone[faceOwner[faceI]];
@@ -2293,6 +2689,214 @@ void Foam::meshRefinement::consistentOrientation
 }
 
 
+void Foam::meshRefinement::zonify
+(
+    // Get per face whether is it master (of a coupled set of faces)
+    const PackedBoolList& isMasterFace,
+    const labelList& cellToZone,
+    const labelList& neiCellZone,
+    const labelList& faceToZone,
+    const boolList& meshFlipMap,
+    polyTopoChange& meshMod
+) const
+{
+    const labelList& faceOwner = mesh_.faceOwner();
+    const labelList& faceNeighbour = mesh_.faceNeighbour();
+
+    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+    {
+        label faceZoneI = faceToZone[faceI];
+
+        if (faceZoneI != -1)
+        {
+            // Orient face zone to have slave cells in min cell zone.
+            label ownZone = cellToZone[faceOwner[faceI]];
+            label neiZone = cellToZone[faceNeighbour[faceI]];
+
+            bool flip;
+
+            if (ownZone == -1 && neiZone == -1)
+            {
+                // free-standing face. Use geometrically derived orientation
+                flip = meshFlipMap[faceI];
+            }
+            else
+            {
+                flip =
+                (
+                    ownZone == -1
+                 || (neiZone != -1 && ownZone > neiZone)
+                );
+            }
+
+            meshMod.setAction
+            (
+                polyModifyFace
+                (
+                    mesh_.faces()[faceI],           // modified face
+                    faceI,                          // label of face
+                    faceOwner[faceI],               // owner
+                    faceNeighbour[faceI],           // neighbour
+                    false,                          // face flip
+                    -1,                             // patch for face
+                    false,                          // remove from zone
+                    faceZoneI,                      // zone for face
+                    flip                            // face flip in zone
+                )
+            );
+        }
+    }
+
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    // Set owner as no-flip
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        label faceI = pp.start();
+
+        forAll(pp, i)
+        {
+            label faceZoneI = faceToZone[faceI];
+
+            if (faceZoneI != -1)
+            {
+                label ownZone = cellToZone[faceOwner[faceI]];
+                label neiZone = neiCellZone[faceI-mesh_.nInternalFaces()];
+
+                bool flip;
+
+                if (ownZone == -1 && neiZone == -1)
+                {
+                    // free-standing face. Use geometrically derived orientation
+                    flip = meshFlipMap[faceI];
+                }
+                else if (ownZone == neiZone)
+                {
+                    // Free-standing zone face or coupled boundary. Keep
+                    // master face unflipped.
+                    flip = !isMasterFace[faceI];
+                }
+                else
+                {
+                    flip =
+                    (
+                        ownZone == -1
+                     || (neiZone != -1 && ownZone > neiZone)
+                    );
+                }
+
+                meshMod.setAction
+                (
+                    polyModifyFace
+                    (
+                        mesh_.faces()[faceI],           // modified face
+                        faceI,                          // label of face
+                        faceOwner[faceI],               // owner
+                        -1,                             // neighbour
+                        false,                          // face flip
+                        patchI,                         // patch for face
+                        false,                          // remove from zone
+                        faceZoneI,                      // zone for face
+                        flip                            // face flip in zone
+                    )
+                );
+            }
+            faceI++;
+        }
+    }
+
+
+    // Put the cells into the correct zone
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(cellToZone, cellI)
+    {
+        label zoneI = cellToZone[cellI];
+
+        if (zoneI >= 0)
+        {
+            meshMod.setAction
+            (
+                polyModifyCell
+                (
+                    cellI,
+                    false,          // removeFromZone
+                    zoneI
+                )
+            );
+        }
+    }
+}
+
+
+void Foam::meshRefinement::allocateInterRegionFaceZone
+(
+    const label ownZone,
+    const label neiZone,
+    wordPairHashTable& zonesToFaceZone,
+    HashTable<word, labelPair, typename labelPair::Hash<> >& zoneIDsToFaceZone
+) const
+{
+    const cellZoneMesh& cellZones = mesh_.cellZones();
+
+    if (ownZone != neiZone)
+    {
+        // Make sure lowest number cellZone is master. Non-cellZone
+        // areas are slave
+        bool swap =
+        (
+            ownZone == -1
+         || (neiZone != -1 && ownZone > neiZone)
+        );
+
+        // Quick check whether we already have pair of zones
+        labelPair key(ownZone, neiZone);
+        if (swap)
+        {
+            Swap(key.first(), key.second());
+        }
+
+        HashTable<word, labelPair, typename labelPair::Hash<> >::
+        const_iterator zoneFnd = zoneIDsToFaceZone.find
+        (
+            key
+        );
+
+        if (zoneFnd == zoneIDsToFaceZone.end())
+        {
+            // Not found. Allocate.
+            const word ownZoneName =
+            (
+                ownZone != -1
+              ? cellZones[ownZone].name()
+              : "none"
+            );
+            const word neiZoneName =
+            (
+                neiZone != -1
+              ? cellZones[neiZone].name()
+              : "none"
+            );
+
+            // Get lowest zone first
+            Pair<word> wordKey(ownZoneName, neiZoneName);
+            if (swap)
+            {
+                Swap(wordKey.first(), wordKey.second());
+            }
+
+            word fzName = wordKey.first() + "_to_" + wordKey.second();
+
+            zoneIDsToFaceZone.insert(key, fzName);
+            zonesToFaceZone.insert(wordKey, fzName);
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Split off unreachable areas of mesh.
@@ -2309,7 +2913,10 @@ void Foam::meshRefinement::baffleAndSplitMesh
     Time& runTime,
     const labelList& globalToMasterPatch,
     const labelList& globalToSlavePatch,
-    const point& keepPoint
+
+    const pointField& locationsInMesh,
+    const wordList& zonesInMesh,
+    const pointField& locationsOutsideMesh
 )
 {
     // Introduce baffles
@@ -2331,6 +2938,10 @@ void Foam::meshRefinement::baffleAndSplitMesh
     getBafflePatches
     (
         globalToMasterPatch,
+
+        locationsInMesh,
+        zonesInMesh,
+
         neiLevel,
         neiCc,
 
@@ -2400,7 +3011,13 @@ void Foam::meshRefinement::baffleAndSplitMesh
         runTime++;
     }
 
-    splitMeshRegions(globalToMasterPatch, globalToSlavePatch, keepPoint);
+    splitMeshRegions
+    (
+        globalToMasterPatch,
+        globalToSlavePatch,
+        locationsInMesh,
+        locationsOutsideMesh
+    );
 
     if (debug)
     {
@@ -2486,13 +3103,15 @@ void Foam::meshRefinement::baffleAndSplitMesh
 }
 
 
-// Split off (with optional buffer layers) unreachable areas of mesh.
 Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
 (
     const label nBufferLayers,
     const labelList& globalToMasterPatch,
     const labelList& globalToSlavePatch,
-    const point& keepPoint
+
+    const pointField& locationsInMesh,
+    const wordList& zonesInMesh,
+    const pointField& locationsOutsideMesh
 )
 {
     // Determine patches to put intersections into
@@ -2503,10 +3122,15 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
     pointField neiCc(mesh_.nFaces()-mesh_.nInternalFaces());
     calcNeighbourData(neiLevel, neiCc);
 
+    // Find intersections with all unnamed(!) surfaces
     labelList ownPatch, neiPatch;
     getBafflePatches
     (
         globalToMasterPatch,
+
+        locationsInMesh,
+        zonesInMesh,
+
         neiLevel,
         neiCc,
 
@@ -2526,39 +3150,25 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
     }
     syncTools::syncFaceList(mesh_, blockedFace, orEqOp<bool>());
 
-    // Set region per cell based on walking
+
     regionSplit cellRegion(mesh_, blockedFace);
     blockedFace.clear();
 
-    // Find the region containing the keepPoint
-    label keepRegionI = findRegion
+    // Set unreachable cells to -1
+    findRegions
     (
         mesh_,
-        cellRegion,
-        mergeDistance_*vector(1,1,1),
-        keepPoint
+        mergeDistance_*vector(1,1,1),   // perturbVec
+        locationsInMesh,
+        locationsOutsideMesh,
+        cellRegion.nRegions(),
+        cellRegion
     );
 
-    Info<< "Found point " << keepPoint
-        << " in global region " << keepRegionI
-        << " out of " << cellRegion.nRegions() << " regions." << endl;
 
-    if (keepRegionI == -1)
-    {
-        FatalErrorIn
-        (
-            "meshRefinement::splitMesh"
-            "(const label, const labelList&, const point&)"
-        )   << "Point " << keepPoint
-            << " is not inside the mesh." << nl
-            << "Bounding box of the mesh:" << mesh_.bounds()
-            << exit(FatalError);
-    }
-
-
-    // Walk out nBufferlayers from region split
+    // Walk out nBufferlayers from region boundary
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // (modifies cellRegion, ownPatch)
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Takes over face patch onto points and then back to faces and cells
     // (so cell-face-point walk)
 
@@ -2585,7 +3195,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
             label ownRegion = cellRegion[faceOwner[faceI]];
             label neiRegion = cellRegion[faceNeighbour[faceI]];
 
-            if (ownRegion == keepRegionI && neiRegion != keepRegionI)
+            if (ownRegion == -1 && neiRegion != -1)
             {
                 // Note max(..) since possibly regionSplit might have split
                 // off extra unreachable parts of mesh. Note: or can this only
@@ -2595,7 +3205,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
                     pointBaffle[f[fp]] = max(defaultPatch, ownPatch[faceI]);
                 }
             }
-            else if (ownRegion != keepRegionI && neiRegion == keepRegionI)
+            else if (ownRegion != -1 && neiRegion == -1)
             {
                 label newPatchI = neiPatch[faceI];
                 if (newPatchI == -1)
@@ -2619,7 +3229,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
 
             label ownRegion = cellRegion[faceOwner[faceI]];
 
-            if (ownRegion == keepRegionI)
+            if (ownRegion == -1)
             {
                 forAll(f, fp)
                 {
@@ -2672,9 +3282,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
             {
                 label own = faceOwner[faceI];
 
-                if (cellRegion[own] != keepRegionI)
+                if (cellRegion[own] == -1)
                 {
-                    cellRegion[own] = keepRegionI;
+                    cellRegion[own] = labelMax;
 
                     const cell& ownFaces = mesh_.cells()[own];
                     forAll(ownFaces, j)
@@ -2689,9 +3299,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
                 {
                     label nei = faceNeighbour[faceI];
 
-                    if (cellRegion[nei] != keepRegionI)
+                    if (cellRegion[nei] == -1)
                     {
-                        cellRegion[nei] = keepRegionI;
+                        cellRegion[nei] = labelMax;
 
                         const cell& neiFaces = mesh_.cells()[nei];
                         forAll(neiFaces, j)
@@ -2720,7 +3330,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
     DynamicList<label> cellsToRemove(mesh_.nCells());
     forAll(cellRegion, cellI)
     {
-        if (cellRegion[cellI] != keepRegionI)
+        if (cellRegion[cellI] == -1)
         {
             cellsToRemove.append(cellI);
         }
@@ -2730,10 +3340,8 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::splitMesh
     label nCellsToKeep = mesh_.nCells() - cellsToRemove.size();
     reduce(nCellsToKeep, sumOp<label>());
 
-    Info<< "Keeping all cells in region " << keepRegionI
-        << " containing point " << keepPoint << endl
-        << "Selected for keeping : " << nCellsToKeep
-        << " cells." << endl;
+    Info<< "Keeping all cells containing points " << locationsInMesh << endl
+        << "Selected for keeping : " << nCellsToKeep << " cells." << endl;
 
 
     // Remove cells
@@ -2794,35 +3402,41 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::dupNonManifoldPoints
         << mesh_.globalData().nTotalPoints()
         << ')' << endl;
 
-    // Topo change engine
-    duplicatePoints pointDuplicator(mesh_);
 
-    // Insert changes into meshMod
-    pointDuplicator.setRefinement(regionSide, meshMod);
+    autoPtr<mapPolyMesh> map;
 
-    // Change the mesh (no inflation, parallel sync)
-    autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-
-    // Update fields
-    mesh_.updateMesh(map);
-
-    // Move mesh if in inflation mode
-    if (map().hasMotionPoints())
+    if (nNonManifPoints)
     {
-        mesh_.movePoints(map().preMotionPoints());
-    }
-    else
-    {
-        // Delete mesh volumes.
-        mesh_.clearOut();
-    }
+        // Topo change engine
+        duplicatePoints pointDuplicator(mesh_);
 
-    // Reset the instance for if in overwrite mode
-    mesh_.setInstance(timeName());
+        // Insert changes into meshMod
+        pointDuplicator.setRefinement(regionSide, meshMod);
 
-    // Update intersections. Is mapping only (no faces created, positions stay
-    // same) so no need to recalculate intersections.
-    updateMesh(map, labelList(0));
+        // Change the mesh (no inflation, parallel sync)
+        map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh if in inflation mode
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes.
+            mesh_.clearOut();
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+
+        // Update intersections. Is mapping only (no faces created, positions
+        // stay same) so no need to recalculate intersections.
+        updateMesh(map, labelList(0));
+    }
 
     return map;
 }
@@ -2839,45 +3453,181 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::dupNonManifoldPoints()
 }
 
 
-// Zoning
-Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergePoints
 (
-    const point& keepPoint,
-    const bool allowFreeStandingZoneFaces
+    const labelList& pointToDuplicate
 )
 {
-    const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
-
-    labelList namedSurfaces(surfaceZonesInfo::getNamedSurfaces(surfZones));
-
-    forAll(namedSurfaces, i)
+    label nPointPairs = 0;
+    forAll(pointToDuplicate, pointI)
     {
-        label surfI = namedSurfaces[i];
+        label otherPointI = pointToDuplicate[pointI];
+        if (otherPointI != -1)
+        {
+            nPointPairs++;
+        }
+    }
 
-        Info<< "Surface : " << surfaces_.names()[surfI] << nl
-            << "    faceZone : " << surfZones[surfI].faceZoneName() << nl
-            << "    cellZone : " << surfZones[surfI].cellZoneName() << endl;
+    autoPtr<mapPolyMesh> map;
+
+    if (returnReduce(nPointPairs, sumOp<label>()))
+    {
+        Map<label> pointToMaster(2*nPointPairs);
+        forAll(pointToDuplicate, pointI)
+        {
+            label otherPointI = pointToDuplicate[pointI];
+            if (otherPointI != -1)
+            {
+                // Slave point
+                pointToMaster.insert(pointI, otherPointI);
+            }
+        }
+
+        // Topochange container
+        polyTopoChange meshMod(mesh_);
+
+        // Insert changes
+        polyMeshAdder::mergePoints(mesh_, pointToMaster, meshMod);
+
+        // Change the mesh (no inflation, parallel sync)
+        map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh if in inflation mode
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes.
+            mesh_.clearOut();
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+
+        // Update intersections. Is mapping only (no faces created, positions
+        // stay same) so no need to recalculate intersections.
+        updateMesh(map, labelList(0));
+    }
+
+    return map;
+}
+
+
+// Duplicate points on 'boundary' zones. Do not duplicate points on
+// 'internal' or 'baffle' zone. Whether points are on normal patches does
+// not matter
+Foam::autoPtr<Foam::mapPolyMesh>
+Foam::meshRefinement::dupNonManifoldBoundaryPoints()
+{
+    const labelList boundaryFaceZones
+    (
+        getZones
+        (
+            List<surfaceZonesInfo::faceZoneType>
+            (
+                1,
+                surfaceZonesInfo::BOUNDARY
+            )
+        )
+    );
+    labelList internalOrBaffleFaceZones;
+    {
+        List<surfaceZonesInfo::faceZoneType> fzTypes(2);
+        fzTypes[0] = surfaceZonesInfo::INTERNAL;
+        fzTypes[1] = surfaceZonesInfo::BAFFLE;
+        internalOrBaffleFaceZones = getZones(fzTypes);
     }
 
 
-    // Add zones to mesh
-    labelList surfaceToFaceZone =
-        surfaceZonesInfo::addFaceZonesToMesh
-        (
-            surfZones,
-            namedSurfaces,
-            mesh_
-        );
 
-    labelList surfaceToCellZone =
-        surfaceZonesInfo::addCellZonesToMesh
-        (
-            surfZones,
-            namedSurfaces,
-            mesh_
-        );
+    // 0 : point used by normal, unzoned boundary faces
+    // 1 : point used by 'boundary' zone
+    // 2 : point used by internal/baffle zone
+    PackedList<2> pointStatus(mesh_.nPoints(), 0u);
+
+    forAll(boundaryFaceZones, j)
+    {
+        const faceZone& fZone = mesh_.faceZones()[boundaryFaceZones[j]];
+        forAll(fZone, i)
+        {
+            const face& f = mesh_.faces()[fZone[i]];
+            forAll(f, fp)
+            {
+                pointStatus[f[fp]] = max(pointStatus[f[fp]], 1u);
+            }
+        }
+    }
+    forAll(internalOrBaffleFaceZones, j)
+    {
+        const faceZone& fZone = mesh_.faceZones()[internalOrBaffleFaceZones[j]];
+        forAll(fZone, i)
+        {
+            const face& f = mesh_.faces()[fZone[i]];
+            forAll(f, fp)
+            {
+                pointStatus[f[fp]] = max(pointStatus[f[fp]], 2u);
+            }
+        }
+    }
+
+    syncTools::syncPointList
+    (
+        mesh_,
+        pointStatus,
+        maxEqOp<unsigned int>(),    // combine op
+        0u                          // null value
+    );
+
+    // Pick up points on boundary zones that are not on internal/baffle zones
+    label n = 0;
+    forAll(pointStatus, pointI)
+    {
+        if (pointStatus[pointI] == 1u)
+        {
+            n++;
+        }
+    }
+
+    label globalNPoints = returnReduce(n, sumOp<label>());
+    Info<< "Duplicating " << globalNPoints << " points on "
+        << " faceZones of type "
+        << surfaceZonesInfo::faceZoneTypeNames[surfaceZonesInfo::BOUNDARY]
+        << endl;
+
+    autoPtr<mapPolyMesh> map;
+
+    if (globalNPoints)
+    {
+        labelList candidatePoints(n);
+        n = 0;
+        forAll(pointStatus, pointI)
+        {
+            if (pointStatus[pointI] == 1u)
+            {
+                candidatePoints[n++] = pointI;
+            }
+        }
+        localPointRegion regionSide(mesh_, candidatePoints);
+        map = dupNonManifoldPoints(regionSide);
+    }
+    return map;
+}
 
 
+// Zoning
+Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
+(
+    const bool allowFreeStandingZoneFaces,
+    const pointField& locationsInMesh,
+    const wordList& zonesInMesh,
+    wordPairHashTable& zonesToFaceZone
+)
+{
     const pointField& cellCentres = mesh_.cellCentres();
     const labelList& faceOwner = mesh_.faceOwner();
     const labelList& faceNeighbour = mesh_.faceNeighbour();
@@ -2890,151 +3640,6 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     calcNeighbourData(neiLevel, neiCc);
 
 
-    // Mark faces intersecting zoned surfaces
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-
-    // Like surfaceIndex_ but only for named surfaces.
-    labelList namedSurfaceIndex(mesh_.nFaces(), -1);
-    PackedBoolList posOrientation(mesh_.nFaces());
-
-    {
-        // Statistics: number of faces per faceZone
-        labelList nSurfFaces(surfZones.size(), 0);
-
-        // 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 (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 faceI = testFaces[i];
-
-            if (mesh_.isInternalFace(faceI))
-            {
-                start[i] = cellCentres[faceOwner[faceI]];
-                end[i] = cellCentres[faceNeighbour[faceI]];
-            }
-            else
-            {
-                start[i] = cellCentres[faceOwner[faceI]];
-                end[i] = neiCc[faceI-mesh_.nInternalFaces()];
-            }
-        }
-
-        // Extend segments a bit
-        {
-            const vectorField smallVec(Foam::sqrt(SMALL)*(end-start));
-            start -= smallVec;
-            end += smallVec;
-        }
-
-
-        // Do test for intersections
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~
-        // Note that we intersect all intersected faces again. Could reuse
-        // the information already in surfaceIndex_.
-
-        labelList surface1;
-        List<pointIndexHit> hit1;
-        vectorField normal1;
-        labelList surface2;
-        List<pointIndexHit> hit2;
-        vectorField normal2;
-        {
-            labelList region1;
-            labelList region2;
-            surfaces_.findNearestIntersection
-            (
-                namedSurfaces,
-                start,
-                end,
-
-                surface1,
-                hit1,
-                region1,
-                normal1,
-
-                surface2,
-                hit2,
-                region2,
-                normal2
-            );
-        }
-
-        forAll(testFaces, i)
-        {
-            label faceI = testFaces[i];
-            const vector& area = mesh_.faceAreas()[faceI];
-
-            if (surface1[i] != -1)
-            {
-                // If both hit should probably choose 'nearest'
-                if
-                (
-                    surface2[i] != -1
-                 && (
-                        magSqr(hit2[i].hitPoint())
-                      < magSqr(hit1[i].hitPoint())
-                    )
-                )
-                {
-                    namedSurfaceIndex[faceI] = surface2[i];
-                    posOrientation[faceI] = ((area&normal2[i]) > 0);
-                    nSurfFaces[surface2[i]]++;
-                }
-                else
-                {
-                    namedSurfaceIndex[faceI] = surface1[i];
-                    posOrientation[faceI] = ((area&normal1[i]) > 0);
-                    nSurfFaces[surface1[i]]++;
-                }
-            }
-            else if (surface2[i] != -1)
-            {
-                namedSurfaceIndex[faceI] = surface2[i];
-                posOrientation[faceI] = ((area&normal2[i]) > 0);
-                nSurfFaces[surface2[i]]++;
-            }
-        }
-
-
-        // surfaceIndex might have different surfaces on both sides if
-        // there happen to be a (obviously thin) surface with different
-        // regions between the cell centres. If one is on a named surface
-        // and the other is not this might give problems so sync.
-        syncTools::syncFaceList
-        (
-            mesh_,
-            namedSurfaceIndex,
-            maxEqOp<label>()
-        );
-
-        // Print a bit
-        if (debug)
-        {
-            forAll(nSurfFaces, surfI)
-            {
-                Pout<< "Surface:"
-                    << surfaces_.names()[surfI]
-                    << "  nZoneFaces:" << nSurfFaces[surfI] << nl;
-            }
-            Pout<< endl;
-        }
-    }
-
 
     // Put the cells into the correct zone
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -3046,97 +3651,492 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     labelList cellToZone(mesh_.nCells(), -2);
 
 
-    // Set using geometric test
+    // Add from locationsInMesh
     // ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    // Closed surfaces with cellZone specified.
-    labelList closedNamedSurfaces
-    (
-        surfaceZonesInfo::getClosedNamedSurfaces
-        (
-            surfZones,
-            surfaces_.geometry(),
-            surfaces_.surfaces()
-        )
-    );
+    // Filter out keepPoints
+    labelList zonedIndices(refinementParameters::zonedLocations(zonesInMesh));
 
-    if (closedNamedSurfaces.size())
+    if (zonedIndices.size())
     {
-        Info<< "Found " << closedNamedSurfaces.size()
-            << " closed, named surfaces. Assigning cells in/outside"
-            << " these surfaces to the corresponding cellZone."
-            << nl << endl;
+        // Explicitly provided locations and their cellZone. Determine all
+        // blocked faces and do walking. Updates cellToZone.
 
-        findCellZoneGeometric
+        Info<< "Setting cellZones according to locationsInMesh:" << endl;
+        //forAll(locationsInMesh, regionI)
+        forAll(zonedIndices, j)
+        {
+            label regionI = zonedIndices[j];
+            Info<< "Location : " << locationsInMesh[regionI] << nl
+                << "    cellZone : " << zonesInMesh[regionI] << endl;
+        }
+        Info<< endl;
+
+        // Test all (unnamed & named) surfaces
+        labelList globalRegion1;
+        labelList globalRegion2;
+        getIntersections
         (
+            identity(surfaces_.surfaces().size()),  // surfacesToTest,
             neiCc,
-            closedNamedSurfaces,    // indices of closed surfaces
-            namedSurfaceIndex,      // per face index of named surface
-            surfaceToCellZone,      // cell zone index per surface
-
-            cellToZone
+            intersectedFaces(),     // testFaces
+            globalRegion1,
+            globalRegion2
         );
-    }
-
-
-    // Set using provided locations
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    labelList locationSurfaces
-    (
-        surfaceZonesInfo::getInsidePointNamedSurfaces(surfZones)
-    );
-
-    if (locationSurfaces.size())
-    {
-        Info<< "Found " << locationSurfaces.size()
-            << " named surfaces with a provided inside point."
-            << " Assigning cells inside these surfaces"
-            << " to the corresponding cellZone."
-            << nl << endl;
 
+        // Assign cellZone according to seed points
         findCellZoneInsideWalk
         (
-            locationSurfaces,       // indices of closed surfaces
-            namedSurfaceIndex,      // per face index of named surface
-            surfaceToCellZone,      // cell zone index per surface
-
+            pointField(locationsInMesh, zonedIndices),       // locations
+            UIndirectList<word>(zonesInMesh, zonedIndices)(),// name of region
+            globalRegion1,          // per face -1 (unblocked) or >= 0 (blocked)
             cellToZone
         );
     }
 
 
-    // Set using walking
-    // ~~~~~~~~~~~~~~~~~
 
+    // Mark faces intersecting zoned surfaces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
+
+    labelList namedSurfaces(surfaceZonesInfo::getNamedSurfaces(surfZones));
+
+
+    //- Face face orientation of zone (only from those intersecting named
+    //  surfaces)
+    PackedBoolList posOrientation(mesh_.nFaces());
+    //- Per face index of faceZone or -1
+    labelList faceToZone(mesh_.nFaces(), -1);
+
+    if (namedSurfaces.size())
     {
-        Info<< "Walking from location-in-mesh " << keepPoint
+        Info<< "Setting cellZones according to named surfaces:" << endl;
+        forAll(namedSurfaces, i)
+        {
+            label surfI = namedSurfaces[i];
+
+            Info<< "Surface : " << surfaces_.names()[surfI] << nl
+                << "    faceZone : " << surfZones[surfI].faceZoneName() << nl
+                << "    cellZone : " << surfZones[surfI].cellZoneName() << endl;
+        }
+        Info<< endl;
+
+
+        // Add zones to mesh
+        labelList surfaceToFaceZone =
+            surfaceZonesInfo::addFaceZonesToMesh
+            (
+                surfZones,
+                namedSurfaces,
+                mesh_
+            );
+
+        labelList surfaceToCellZone =
+            surfaceZonesInfo::addCellZonesToMesh
+            (
+                surfZones,
+                namedSurfaces,
+                mesh_
+            );
+
+
+
+
+        // Like surfaceIndex_ but only for named surfaces.
+        labelList namedSurfaceIndex(mesh_.nFaces(), -1);
+
+        {
+            // Statistics: number of faces per faceZone
+            labelList nSurfFaces(surfZones.size(), 0);
+
+            // 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 (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 faceI = testFaces[i];
+
+                if (mesh_.isInternalFace(faceI))
+                {
+                    start[i] = cellCentres[faceOwner[faceI]];
+                    end[i] = cellCentres[faceNeighbour[faceI]];
+                }
+                else
+                {
+                    start[i] = cellCentres[faceOwner[faceI]];
+                    end[i] = neiCc[faceI-mesh_.nInternalFaces()];
+                }
+            }
+
+            // Extend segments a bit
+            {
+                const vectorField smallVec(Foam::sqrt(SMALL)*(end-start));
+                start -= smallVec;
+                end += smallVec;
+            }
+
+
+            // Do test for intersections
+            // ~~~~~~~~~~~~~~~~~~~~~~~~~
+            // Note that we intersect all intersected faces again. Could reuse
+            // the information already in surfaceIndex_.
+
+            labelList surface1;
+            List<pointIndexHit> hit1;
+            vectorField normal1;
+            labelList surface2;
+            List<pointIndexHit> hit2;
+            vectorField normal2;
+            {
+                labelList region1;
+                labelList region2;
+                surfaces_.findNearestIntersection
+                (
+                    namedSurfaces,
+                    start,
+                    end,
+
+                    surface1,
+                    hit1,
+                    region1,
+                    normal1,
+
+                    surface2,
+                    hit2,
+                    region2,
+                    normal2
+                );
+            }
+
+            forAll(testFaces, i)
+            {
+                label faceI = testFaces[i];
+                const vector& area = mesh_.faceAreas()[faceI];
+
+                if (surface1[i] != -1)
+                {
+                    // If both hit should probably choose 'nearest'
+                    if
+                    (
+                        surface2[i] != -1
+                     && (
+                            magSqr(hit2[i].hitPoint())
+                          < magSqr(hit1[i].hitPoint())
+                        )
+                    )
+                    {
+                        namedSurfaceIndex[faceI] = surface2[i];
+                        posOrientation[faceI] = ((area&normal2[i]) > 0);
+                        nSurfFaces[surface2[i]]++;
+                    }
+                    else
+                    {
+                        namedSurfaceIndex[faceI] = surface1[i];
+                        posOrientation[faceI] = ((area&normal1[i]) > 0);
+                        nSurfFaces[surface1[i]]++;
+                    }
+                }
+                else if (surface2[i] != -1)
+                {
+                    namedSurfaceIndex[faceI] = surface2[i];
+                    posOrientation[faceI] = ((area&normal2[i]) > 0);
+                    nSurfFaces[surface2[i]]++;
+                }
+            }
+
+
+            // surfaceIndex might have different surfaces on both sides if
+            // there happen to be a (obviously thin) surface with different
+            // regions between the cell centres. If one is on a named surface
+            // and the other is not this might give problems so sync.
+            syncTools::syncFaceList
+            (
+                mesh_,
+                namedSurfaceIndex,
+                maxEqOp<label>()
+            );
+
+            // Print a bit
+            if (debug)
+            {
+                forAll(nSurfFaces, surfI)
+                {
+                    Pout<< "Surface:"
+                        << surfaces_.names()[surfI]
+                        << "  nZoneFaces:" << nSurfFaces[surfI] << nl;
+                }
+                Pout<< endl;
+            }
+        }
+
+
+        // Now we have for all faces the intersection with a named surfaces (or
+        // -1). Use this information to set zone of cells
+
+        // Set using geometric test
+        // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+        // Closed surfaces with cellZone specified.
+        labelList closedNamedSurfaces
+        (
+            surfaceZonesInfo::getClosedNamedSurfaces
+            (
+                surfZones,
+                surfaces_.geometry(),
+                surfaces_.surfaces()
+            )
+        );
+
+        if (closedNamedSurfaces.size())
+        {
+            Info<< "Found " << closedNamedSurfaces.size()
+                << " closed, named surfaces. Assigning cells in/outside"
+                << " these surfaces to the corresponding cellZone."
+                << nl << endl;
+
+            findCellZoneGeometric
+            (
+                neiCc,
+                closedNamedSurfaces,    // indices of closed surfaces
+                namedSurfaceIndex,      // per face index of named surface
+                surfaceToCellZone,      // cell zone index per surface
+
+                cellToZone
+            );
+        }
+
+
+        // Set using provided locations
+        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+        labelList locationSurfaces
+        (
+            surfaceZonesInfo::getInsidePointNamedSurfaces(surfZones)
+        );
+
+        if (locationSurfaces.size())
+        {
+            Info<< "Found " << locationSurfaces.size()
+                << " named surfaces with a provided inside point."
+                << " Assigning cells inside these surfaces"
+                << " to the corresponding cellZone."
+                << nl << endl;
+
+            findCellZoneInsideWalk
+            (
+                locationSurfaces,       // indices of closed surfaces
+                namedSurfaceIndex,      // per face index of named surface
+                surfaceToCellZone,      // cell zone index per surface
+
+                cellToZone
+            );
+        }
+
+
+        // Set using walking
+        // ~~~~~~~~~~~~~~~~~
+
+        Info<< "Walking from " << locationsInMesh.size()
+            << " locations-in-mesh "
             << " to assign cellZones "
             << "- crossing a faceZone face changes cellZone" << nl << endl;
 
-        // Topological walk
+        labelList zoneIDs(refinementParameters::unzonedLocations(zonesInMesh));
+
         findCellZoneTopo
         (
-            keepPoint,
+            pointField(locationsInMesh, zoneIDs),
             namedSurfaceIndex,
             surfaceToCellZone,
 
             cellToZone
         );
+
+
+        // Make sure namedSurfaceIndex is unset inbetween same cell zones.
+        if (!allowFreeStandingZoneFaces)
+        {
+            Info<< "Only keeping zone faces inbetween different cellZones."
+                << nl << endl;
+
+            makeConsistentFaceIndex(cellToZone, namedSurfaceIndex);
+        }
+
+
+        // Convert namedSurfaceIndex (index of named surfaces) to
+        // actual faceZone index
+
+        forAll(namedSurfaceIndex, faceI)
+        {
+            label surfI = namedSurfaceIndex[faceI];
+            if (surfI != -1)
+            {
+                faceToZone[faceI] = surfaceToFaceZone[surfI];
+            }
+        }
     }
 
 
-    // Make sure namedSurfaceIndex is unset inbetween same cell cell zones.
-    if (!allowFreeStandingZoneFaces)
+
+    // Allocate and assign faceZones from cellZones
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
     {
-        Info<< "Only keeping zone faces inbetween different cellZones."
-            << nl << endl;
+        // 1. Detect inter-region face and allocate names
 
-        makeConsistentFaceIndex(cellToZone, namedSurfaceIndex);
+        HashTable<word, labelPair, typename labelPair::Hash<> >
+            zoneIDsToFaceZone;
+
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            if (faceToZone[faceI] == -1)
+            {
+                // Face not yet in a faceZone. (it might already have been
+                // done so by a 'named' surface). Check if inbetween different
+                // cellZones
+                allocateInterRegionFaceZone
+                (
+                    cellToZone[mesh_.faceOwner()[faceI]],
+                    cellToZone[mesh_.faceNeighbour()[faceI]],
+                    zonesToFaceZone,
+                    zoneIDsToFaceZone
+                );
+            }
+        }
+
+        labelList neiCellZone;
+        syncTools::swapBoundaryCellList(mesh_, cellToZone, neiCellZone);
+
+        forAll(neiCellZone, bFaceI)
+        {
+            label faceI = bFaceI + mesh_.nInternalFaces();
+            if (faceToZone[faceI] == -1)
+            {
+                allocateInterRegionFaceZone
+                (
+                    cellToZone[mesh_.faceOwner()[faceI]],
+                    neiCellZone[bFaceI],
+                    zonesToFaceZone,
+                    zoneIDsToFaceZone
+                );
+            }
+        }
+
+
+        // 2.Combine faceZoneNames allocated on different processors
+
+        Pstream::mapCombineGather(zonesToFaceZone, eqOp<word>());
+        Pstream::mapCombineScatter(zonesToFaceZone);
+
+
+        // 3. Allocate faceZones from (now synchronised) faceZoneNames
+
+        Info<< "Setting faceZones according to neighbouring cellZones:"
+            << endl;
+
+        // From cellZone indices to faceZone index
+        HashTable<label, labelPair, typename labelPair::Hash<> > fZoneLookup
+        (
+            zonesToFaceZone.size()
+        );
+
+        const cellZoneMesh& cellZones = mesh_.cellZones();
+
+        forAllConstIter(wordPairHashTable, zonesToFaceZone, iter)
+        {
+            const Pair<word>& cz = iter.key();
+            const word& fzName = iter();
+
+            Info<< indent<< "cellZones : "
+                << cz[0] << ' ' << cz[1] << nl
+                << "    faceZone : " << fzName << endl;
+
+            label faceZoneI = surfaceZonesInfo::addFaceZone
+            (
+                fzName,                 // name
+                labelList(0),           // addressing
+                boolList(0),            // flipMap
+                mesh_
+            );
+
+            label cz0 = cellZones.findZoneID(cz[0]);
+            label cz1 = cellZones.findZoneID(cz[1]);
+
+            fZoneLookup.insert(labelPair(cz0, cz1), faceZoneI);
+        }
+
+
+        // 4. Set faceToZone with new faceZones
+
+
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            if (faceToZone[faceI] == -1)
+            {
+                // Face not yet in a faceZone. (it might already have been
+                // done so by a 'named' surface). Check if inbetween different
+                // cellZones
+
+                label ownZone = cellToZone[mesh_.faceOwner()[faceI]];
+                label neiZone = cellToZone[mesh_.faceNeighbour()[faceI]];
+                if (ownZone != neiZone)
+                {
+                    bool swap =
+                    (
+                        ownZone == -1
+                     || (neiZone != -1 && ownZone > neiZone)
+                    );
+                    labelPair key(ownZone, neiZone);
+                    if (swap)
+                    {
+                        Swap(key.first(), key.second());
+                    }
+                    faceToZone[faceI] = fZoneLookup[key];
+                }
+            }
+        }
+        forAll(neiCellZone, bFaceI)
+        {
+            label faceI = bFaceI + mesh_.nInternalFaces();
+            if (faceToZone[faceI] == -1)
+            {
+                label ownZone = cellToZone[mesh_.faceOwner()[faceI]];
+                label neiZone = neiCellZone[bFaceI];
+                if (ownZone != neiZone)
+                {
+                    bool swap =
+                    (
+                        ownZone == -1
+                     || (neiZone != -1 && ownZone > neiZone)
+                    );
+                    labelPair key(ownZone, neiZone);
+                    if (swap)
+                    {
+                        Swap(key.first(), key.second());
+                    }
+                    faceToZone[faceI] = fZoneLookup[key];
+                }
+            }
+        }
+        Info<< endl;
     }
 
-    // Topochange container
-    polyTopoChange meshMod(mesh_);
 
 
 
@@ -3162,7 +4162,6 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     const PackedBoolList isMasterFace(syncTools::getMasterFaces(mesh_));
 
 
-
     // faceZones
     // ~~~~~~~~~
     // Faces on faceZones come in two variants:
@@ -3183,7 +4182,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
                 mesh_.faces(),
                 freeStandingBaffleFaces
                 (
-                    namedSurfaceIndex,
+                    faceToZone,
                     cellToZone,
                     neiCellZone
                 )
@@ -3203,12 +4202,12 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
 
             // Mark zones. Even a single original surface might create multiple
             // disconnected/non-manifold-connected zones
-            labelList faceToZone;
+            labelList faceToConnectedZone;
             const label nZones = markPatchZones
             (
                 patch,
                 nMasterFacesPerEdge,
-                faceToZone
+                faceToConnectedZone
             );
 
             Map<label> nPosOrientation(2*nZones);
@@ -3225,7 +4224,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
                 isMasterFace,
                 patch,
                 nMasterFacesPerEdge,
-                faceToZone,
+                faceToConnectedZone,
                 nPosOrientation,
 
                 meshFlipMap
@@ -3249,7 +4248,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
                         n = -1;
                     }
 
-                    nPosOrientation.find(faceToZone[faceI])() += n;
+                    nPosOrientation.find(faceToConnectedZone[faceI])() += n;
                 }
             }
             Pstream::mapCombineGather(nPosOrientation, plusEqOp<label>());
@@ -3269,14 +4268,14 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
             Info<< endl;
 
 
-            // Reapply with new counts (in nPosOrientation). This will cause
+            // Re-apply with new counts (in nPosOrientation). This will cause
             // zones with a negative count to be flipped.
             consistentOrientation
             (
                 isMasterFace,
                 patch,
                 nMasterFacesPerEdge,
-                faceToZone,
+                faceToConnectedZone,
                 nPosOrientation,
 
                 meshFlipMap
@@ -3285,137 +4284,21 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     }
 
 
-    // Put the faces into the correct zone
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
-    {
-        label surfI = namedSurfaceIndex[faceI];
-
-        if (surfI != -1)
-        {
-            // Orient face zone to have slave cells in max cell zone.
-            label ownZone = cellToZone[faceOwner[faceI]];
-            label neiZone = cellToZone[faceNeighbour[faceI]];
-
-            bool flip;
-
-            label maxZone = max(ownZone, neiZone);
-
-            if (maxZone == -1)
-            {
-                // free-standing face. Use geometrically derived orientation
-                flip = meshFlipMap[faceI];
-            }
-            else if (ownZone == maxZone)
-            {
-                flip = false;
-            }
-            else
-            {
-                flip = true;
-            }
-
-            meshMod.setAction
-            (
-                polyModifyFace
-                (
-                    mesh_.faces()[faceI],           // modified face
-                    faceI,                          // label of face
-                    faceOwner[faceI],               // owner
-                    faceNeighbour[faceI],           // neighbour
-                    false,                          // face flip
-                    -1,                             // patch for face
-                    false,                          // remove from zone
-                    surfaceToFaceZone[surfI],       // zone for face
-                    flip                            // face flip in zone
-                )
-            );
-        }
-    }
 
 
-    // Set owner as no-flip
-    forAll(patches, patchI)
-    {
-        const polyPatch& pp = patches[patchI];
+    // Topochange container
+    polyTopoChange meshMod(mesh_);
 
-        label faceI = pp.start();
-
-        forAll(pp, i)
-        {
-            label surfI = namedSurfaceIndex[faceI];
-
-            if (surfI != -1)
-            {
-                label ownZone = cellToZone[faceOwner[faceI]];
-                label neiZone = neiCellZone[faceI-mesh_.nInternalFaces()];
-
-                bool flip;
-
-                label maxZone = max(ownZone, neiZone);
-
-                if (maxZone == -1)
-                {
-                    // free-standing face. Use geometrically derived orientation
-                    flip = meshFlipMap[faceI];
-                }
-                else if (ownZone == neiZone)
-                {
-                    // Free-standing zone face or coupled boundary. Keep master
-                    // face unflipped.
-                    flip = !isMasterFace[faceI];
-                }
-                else if (neiZone == maxZone)
-                {
-                    flip = true;
-                }
-                else
-                {
-                    flip = false;
-                }
-
-                meshMod.setAction
-                (
-                    polyModifyFace
-                    (
-                        mesh_.faces()[faceI],           // modified face
-                        faceI,                          // label of face
-                        faceOwner[faceI],               // owner
-                        -1,                             // neighbour
-                        false,                          // face flip
-                        patchI,                         // patch for face
-                        false,                          // remove from zone
-                        surfaceToFaceZone[surfI],       // zone for face
-                        flip                            // face flip in zone
-                    )
-                );
-            }
-            faceI++;
-        }
-    }
-
-
-    // Put the cells into the correct zone
-    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    forAll(cellToZone, cellI)
-    {
-        label zoneI = cellToZone[cellI];
-
-        if (zoneI >= 0)
-        {
-            meshMod.setAction
-            (
-                polyModifyCell
-                (
-                    cellI,
-                    false,          // removeFromZone
-                    zoneI
-                )
-            );
-        }
-    }
+    // Insert changes to put cells and faces into zone
+    zonify
+    (
+        isMasterFace,
+        cellToZone,
+        neiCellZone,
+        faceToZone,
+        meshFlipMap,
+        meshMod
+    );
 
     // Change the mesh (no inflation, parallel sync)
     autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
diff --git a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
index 4fc1b40077..bb8ee5e3b5 100644
--- a/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
+++ b/src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementMerge.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,110 +34,115 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-//// Merge faces that are in-line.
-//Foam::label Foam::meshRefinement::mergePatchFaces
-//(
-//    const scalar minCos,
-//    const scalar concaveCos,
-//    const labelList& patchIDs
-//)
-//{
-//    // Patch face merging engine
-//    combineFaces faceCombiner(mesh_);
-//
-//    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
-//
-//    // Pick up all candidate cells on boundary
-//    labelHashSet boundaryCells(mesh_.nFaces()-mesh_.nInternalFaces());
-//
-//    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 mergeSets
-//    (
-//        faceCombiner.getMergeSets
-//        (
-//            minCos,
-//            concaveCos,
-//            boundaryCells
-//        )
-//    );
-//
-//    label nFaceSets = returnReduce(mergeSets.size(), sumOp<label>());
-//
-//    Info<< "mergePatchFaces : Merging " << nFaceSets
-//        << " sets of faces." << endl;
-//
-//    if (nFaceSets > 0)
-//    {
-//        // Topology changes container
-//        polyTopoChange meshMod(mesh_);
-//
-//        // Merge all faces of a set into the first face of the set. Remove
-//        // unused points.
-//        faceCombiner.setRefinement(mergeSets, meshMod);
-//
-//        // Change the mesh (no inflation)
-//        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
-//
-//        // Update fields
-//        mesh_.updateMesh(map);
-//
-//        // Move mesh (since morphing does not do this)
-//        if (map().hasMotionPoints())
-//        {
-//            mesh_.movePoints(map().preMotionPoints());
-//        }
-//        else
-//        {
-//            // Delete mesh volumes. No other way to do this?
-//            mesh_.clearOut();
-//        }
-//
-//
-//        // Reset the instance for if in overwrite mode
-//        mesh_.setInstance(timeName());
-//
-//        faceCombiner.updateMesh(map);
-//
-//        // Get the kept faces that need to be recalculated.
-//        // Merging two boundary faces might shift the cell centre
-//        // (unless the faces are absolutely planar)
-//        labelHashSet retestFaces(6*mergeSets.size());
-//
-//        forAll(mergeSets, setI)
-//        {
-//            label oldMasterI = mergeSets[setI][0];
-//
-//            label faceI = map().reverseFaceMap()[oldMasterI];
-//
-//            // faceI is always uncoupled boundary face
-//            const cell& cFaces = mesh_.cells()[mesh_.faceOwner()[faceI]];
-//
-//            forAll(cFaces, i)
-//            {
-//                retestFaces.insert(cFaces[i]);
-//            }
-//        }
-//        updateMesh(map, retestFaces.toc());
-//    }
-//
-//
-//    return nFaceSets;
-//}
+// Merge faces that are in-line.
+Foam::label Foam::meshRefinement::mergePatchFaces
+(
+    const scalar minCos,
+    const scalar concaveCos,
+    const label mergeSize,
+    const labelList& patchIDs
+)
+{
+    // Patch face merging engine
+    combineFaces faceCombiner(mesh_, false);
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    // Pick up all candidate cells on boundary
+    labelHashSet boundaryCells(mesh_.nFaces()-mesh_.nInternalFaces());
+
+    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 mergeSets
+    (
+        faceCombiner.getMergeSets
+        (
+            minCos,
+            concaveCos,
+            boundaryCells
+        )
+    );
+
+    if (mergeSize != -1)
+    {
+        // Keep only those that are mergeSize faces
+        label compactI = 0;
+        forAll(mergeSets, setI)
+        {
+            if (mergeSets[setI].size() == mergeSize)
+            {
+                mergeSets[compactI++] = mergeSets[setI];
+            }
+        }
+        mergeSets.setSize(compactI);
+    }
+
+
+    label nFaceSets = returnReduce(mergeSets.size(), sumOp<label>());
+
+    Info<< "Merging " << nFaceSets << " sets of faces." << nl << endl;
+
+    if (nFaceSets > 0)
+    {
+        // Topology changes container
+        polyTopoChange meshMod(mesh_);
+
+        // Merge all faces of a set into the first face of the set. Remove
+        // unused points.
+        faceCombiner.setRefinement(mergeSets, meshMod);
+
+        // Change the mesh (no inflation)
+        autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
+
+        // Update fields
+        mesh_.updateMesh(map);
+
+        // Move mesh (since morphing does not do this)
+        if (map().hasMotionPoints())
+        {
+            mesh_.movePoints(map().preMotionPoints());
+        }
+        else
+        {
+            // Delete mesh volumes. No other way to do this?
+            mesh_.clearOut();
+        }
+
+        // Reset the instance for if in overwrite mode
+        mesh_.setInstance(timeName());
+
+        faceCombiner.updateMesh(map);
+
+        // Get the kept faces that need to be recalculated.
+        // Merging two boundary faces might shift the cell centre
+        // (unless the faces are absolutely planar)
+        labelHashSet retestFaces(2*mergeSets.size());
+
+        forAll(mergeSets, setI)
+        {
+            label oldMasterI = mergeSets[setI][0];
+            retestFaces.insert(map().reverseFaceMap()[oldMasterI]);
+        }
+        updateMesh(map, growFaceCellFace(retestFaces));
+    }
+
+    return nFaceSets;
+}
+
 //
 //
 //// Remove points not used by any face or points used by only two faces where
diff --git a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.C b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.C
index 69c3f7777b..4339b651db 100644
--- a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.C
+++ b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -341,6 +341,37 @@ Foam::labelList Foam::surfaceZonesInfo::getInsidePointNamedSurfaces
 }
 
 
+Foam::label Foam::surfaceZonesInfo::addCellZone
+(
+    const word& name,
+    const labelList& addressing,
+    polyMesh& mesh
+)
+{
+    cellZoneMesh& cellZones = mesh.cellZones();
+
+    label zoneI = cellZones.findZoneID(name);
+
+    if (zoneI == -1)
+    {
+        zoneI = cellZones.size();
+        cellZones.setSize(zoneI+1);
+        cellZones.set
+        (
+            zoneI,
+            new cellZone
+            (
+                name,           // name
+                addressing,     // addressing
+                zoneI,          // index
+                cellZones       // cellZoneMesh
+            )
+        );
+    }
+    return zoneI;
+}
+
+
 Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
 (
     const PtrList<surfaceZonesInfo>& surfList,
@@ -350,8 +381,6 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
 {
     labelList surfaceToCellZone(surfList.size(), -1);
 
-    cellZoneMesh& cellZones = mesh.cellZones();
-
     forAll(namedSurfaces, i)
     {
         label surfI = namedSurfaces[i];
@@ -360,24 +389,12 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
 
         if (cellZoneName != word::null)
         {
-            label zoneI = cellZones.findZoneID(cellZoneName);
-
-            if (zoneI == -1)
-            {
-                zoneI = cellZones.size();
-                cellZones.setSize(zoneI+1);
-                cellZones.set
-                (
-                    zoneI,
-                    new cellZone
-                    (
-                        cellZoneName,   //name
-                        labelList(0),   //addressing
-                        zoneI,          //index
-                        cellZones       //cellZoneMesh
-                    )
-                );
-            }
+            label zoneI = addCellZone
+            (
+                cellZoneName,
+                labelList(0),   // addressing
+                mesh
+            );
 
             surfaceToCellZone[surfI] = zoneI;
         }
@@ -385,7 +402,7 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
 
     // Check they are synced
     List<wordList> allCellZones(Pstream::nProcs());
-    allCellZones[Pstream::myProcNo()] = cellZones.names();
+    allCellZones[Pstream::myProcNo()] = mesh.cellZones().names();
     Pstream::gatherList(allCellZones);
     Pstream::scatterList(allCellZones);
 
@@ -409,6 +426,40 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
 }
 
 
+
+Foam::label Foam::surfaceZonesInfo::addFaceZone
+(
+    const word& name,
+    const labelList& addressing,
+    const boolList& flipMap,
+    polyMesh& mesh
+)
+{
+    faceZoneMesh& faceZones = mesh.faceZones();
+
+    label zoneI = faceZones.findZoneID(name);
+
+    if (zoneI == -1)
+    {
+        zoneI = faceZones.size();
+        faceZones.setSize(zoneI+1);
+        faceZones.set
+        (
+            zoneI,
+            new faceZone
+            (
+                name,           // name
+                addressing,     // addressing
+                flipMap,        // flipMap
+                zoneI,          // index
+                faceZones       // faceZoneMesh
+            )
+        );
+    }
+    return zoneI;
+}
+
+
 Foam::labelList Foam::surfaceZonesInfo::addFaceZonesToMesh
 (
     const PtrList<surfaceZonesInfo>& surfList,
@@ -426,25 +477,13 @@ Foam::labelList Foam::surfaceZonesInfo::addFaceZonesToMesh
 
         const word& faceZoneName = surfList[surfI].faceZoneName();
 
-        label zoneI = faceZones.findZoneID(faceZoneName);
-
-        if (zoneI == -1)
-        {
-            zoneI = faceZones.size();
-            faceZones.setSize(zoneI+1);
-            faceZones.set
-            (
-                zoneI,
-                new faceZone
-                (
-                    faceZoneName,   //name
-                    labelList(0),   //addressing
-                    boolList(0),    //flipmap
-                    zoneI,          //index
-                    faceZones       //faceZoneMesh
-                )
-            );
-        }
+        label zoneI = addFaceZone
+        (
+            faceZoneName,   //name
+            labelList(0),   //addressing
+            boolList(0),    //flipmap
+            mesh
+        );
 
         surfaceToFaceZone[surfI] = zoneI;
     }
diff --git a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.H b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.H
index eb59aad34f..a18d111133 100644
--- a/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.H
+++ b/src/mesh/autoMesh/autoHexMesh/refinementSurfaces/surfaceZonesInfo.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,6 +39,7 @@ SourceFiles
 #include "word.H"
 #include "PtrList.H"
 #include "labelList.H"
+#include "boolList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -222,6 +223,13 @@ public:
                 const PtrList<surfaceZonesInfo>& surfList
             );
 
+            static label addCellZone
+            (
+                const word& name,
+                const labelList& addressing,
+                polyMesh& mesh
+            );
+
             static labelList addCellZonesToMesh
             (
                 const PtrList<surfaceZonesInfo>& surfList,
@@ -229,6 +237,14 @@ public:
                 polyMesh& mesh
             );
 
+            static label addFaceZone
+            (
+                const word& name,
+                const labelList& addressing,
+                const boolList& flipMap,
+                polyMesh& mesh
+            );
+
             static labelList addFaceZonesToMesh
             (
                 const PtrList<surfaceZonesInfo>& surfList,

From b299b6b6ee13ef7e4aac84993543e107db7c9620 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 26 Feb 2014 14:50:04 +0000
Subject: [PATCH 3/4] ENH: foamRunTutorials: specify name of log file

---
 bin/tools/RunFunctions                        | 34 ++++++++++++++-----
 .../boundaryWallFunctionsProfile/Allrun       |  8 ++---
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/bin/tools/RunFunctions b/bin/tools/RunFunctions
index 3632a62d76..07ce5f2771 100644
--- a/bin/tools/RunFunctions
+++ b/bin/tools/RunFunctions
@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -40,28 +40,46 @@ getApplication()
 
 runApplication()
 {
+    APP_LOGFILE=''
+    if [ "$1" = "-l" ]
+    then
+        APP_LOGFILE=$2
+        shift 2
+    fi
+
     APP_RUN=$1
     APP_NAME=${1##*/}
     shift
 
-    if [ -f log.$APP_NAME ]
+    APP_LOGFILE=${APP_LOGFILE:="log.$APP_NAME"}
+
+    if [ -f $APP_LOGFILE ]
     then
-        echo "$APP_NAME already run on $PWD: remove log file to re-run"
+        echo "$APP_NAME already run on $PWD: remove log file $APP_LOGFILE to re-run"
     else
         echo "Running $APP_RUN on $PWD"
-        $APP_RUN "$@" > log.$APP_NAME 2>&1
+        $APP_RUN "$@" > $APP_LOGFILE 2>&1
     fi
 }
 
 runParallel()
 {
+    APP_LOGFILE=''
+    if [ "$1" = "-l" ]
+    then
+        APP_LOGFILE=$2
+        shift 2
+    fi
+
     APP_RUN=$1
     APP_NAME=${1##*/}
     shift
 
-    if [ -f log.$APP_NAME ]
+    APP_LOGFILE=${APP_LOGFILE:="log.$APP_NAME"}
+
+    if [ -f $APP_LOGFILE ]
     then
-        echo "$APP_NAME already run on $PWD: remove log file to re-run"
+        echo "$APP_NAME already run on $PWD: remove log file $APP_LOGFILE to re-run"
     else
         nProcs=$1
         shift
@@ -70,9 +88,9 @@ runParallel()
         #if [ "$WM_SCHEDULER" ]
         #then
         #    echo "$PWD: $WM_SCHEDULER -np $nProcs" 1>&2
-        #    $WM_SCHEDULER -np $nProcs "( mpirun -np $nProcs $APP_RUN -parallel "$@" < /dev/null > log.$APP_NAME 2>&1 )"
+        #    $WM_SCHEDULER -np $nProcs "( mpirun -np $nProcs $APP_RUN -parallel "$@" < /dev/null > $APP_LOGFILE 2>&1 )"
         #else
-            ( mpirun -np $nProcs $APP_RUN -parallel "$@" < /dev/null > log.$APP_NAME 2>&1 )
+            ( mpirun -np $nProcs $APP_RUN -parallel "$@" < /dev/null > $APP_LOGFILE 2>&1 )
         #fi
     fi
 }
diff --git a/tutorials/incompressible/boundaryFoam/boundaryWallFunctionsProfile/Allrun b/tutorials/incompressible/boundaryFoam/boundaryWallFunctionsProfile/Allrun
index a3f07091ff..bcc5342a13 100755
--- a/tutorials/incompressible/boundaryFoam/boundaryWallFunctionsProfile/Allrun
+++ b/tutorials/incompressible/boundaryFoam/boundaryWallFunctionsProfile/Allrun
@@ -17,15 +17,11 @@ do
     sed "s/XXX/$e/g" constant/transportProperties.template \
         > constant/transportProperties
 
-    runApplication `getApplication`
-
-    mv log.boundaryFoam log.boundaryFoam_$e
+    runApplication -l log.boundaryFoam_$e `getApplication`
 
     # extract y+, U+
     # note: both must be added to foamLog.db
-    runApplication foamLog log.boundaryFoam_$e
-
-    mv log.foamLog log.foamLog_$e
+    runApplication -l log.foamLog_$e foamLog log.boundaryFoam_$e
 
     if [ -e logs/yPlus_0 ]
     then

From 64f13eb9db646c997ee6fa8391b9531f6b1a8bc0 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs>
Date: Wed, 26 Feb 2014 15:25:48 +0000
Subject: [PATCH 4/4] ENH: motorBike: tutorial with dynamic refinement across
 snappyHexMesh mesh

---
 .../interDyMFoam/ras/motorBike/0.org/U        |  40 +++
 .../ras/motorBike/0.org/alpha.water           |  38 +++
 .../interDyMFoam/ras/motorBike/0.org/p_rgh    |  46 +++
 .../interDyMFoam/ras/motorBike/Allclean       |  15 +
 .../interDyMFoam/ras/motorBike/Allrun         |  15 +
 .../interDyMFoam/ras/motorBike/Allrun.pre     |  27 ++
 .../ras/motorBike/constant/RASProperties      |  24 ++
 .../ras/motorBike/constant/dynamicMeshDict    |  50 +++
 .../interDyMFoam/ras/motorBike/constant/g     |  22 ++
 .../motorBike/constant/polyMesh/blockMeshDict |  89 +++++
 .../motorBike/constant/transportProperties    |  67 ++++
 .../ras/motorBike/constant/triSurface/README  |   4 +
 .../motorBike/constant/turbulenceProperties   |  21 ++
 .../ras/motorBike/system/controlDict          |  60 ++++
 .../ras/motorBike/system/decomposeParDict     |  42 +++
 .../ras/motorBike/system/fvSchemes            |  59 ++++
 .../ras/motorBike/system/fvSolution           |  83 +++++
 .../ras/motorBike/system/meshQualityDict      |  24 ++
 .../ras/motorBike/system/setFieldsDict        |  38 +++
 .../ras/motorBike/system/snappyHexMeshDict    | 314 ++++++++++++++++++
 .../system/surfaceFeatureExtractDict          |  48 +++
 21 files changed, 1126 insertions(+)
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/U
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/alpha.water
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/p_rgh
 create mode 100755 tutorials/multiphase/interDyMFoam/ras/motorBike/Allclean
 create mode 100755 tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun
 create mode 100755 tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun.pre
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/RASProperties
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/dynamicMeshDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/g
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/polyMesh/blockMeshDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/transportProperties
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/triSurface/README
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/constant/turbulenceProperties
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/controlDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/decomposeParDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSchemes
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSolution
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/meshQualityDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/setFieldsDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/snappyHexMeshDict
 create mode 100644 tutorials/multiphase/interDyMFoam/ras/motorBike/system/surfaceFeatureExtractDict

diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/U b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/U
new file mode 100644
index 0000000000..77100e9c9b
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/U
@@ -0,0 +1,40 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    location    "0";
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    //- Set patchGroups for constraint patches
+    #include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
+
+    wall
+    {
+        type            uniformFixedValue;
+        uniformValue    (0 0 0);
+    }
+    upperWall
+    {
+        type            pressureInletOutletVelocity;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/alpha.water b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/alpha.water
new file mode 100644
index 0000000000..f48a5159cf
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/alpha.water
@@ -0,0 +1,38 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      alpha.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    //- Set patchGroups for constraint patches
+    #include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
+
+    wall
+    {
+        type            zeroGradient;
+    }
+    upperWall
+    {
+        type            inletOutlet;
+        inletValue      uniform 0;
+        value           uniform 0;
+    }
+}
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/p_rgh b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/p_rgh
new file mode 100644
index 0000000000..153f206474
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/0.org/p_rgh
@@ -0,0 +1,46 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p_rgh;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -2 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    //- Set patchGroups for constraint patches
+    #include "${WM_PROJECT_DIR}/etc/caseDicts/setConstraintTypes"
+
+    wall
+    {
+        type            fixedFluxPressure;
+        phi             phiAbs;
+        value           uniform 0;
+    }
+
+    upperWall
+    {
+        type            totalPressure;
+        p0              uniform 0;
+        U               U;
+        phi             phi;
+        rho             rho;
+        psi             none;
+        gamma           1;
+        value           uniform 0;
+    }
+}
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/Allclean b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allclean
new file mode 100755
index 0000000000..0ce70bfacc
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allclean
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+# Source tutorial clean functions
+. $WM_PROJECT_DIR/bin/tools/CleanFunctions
+
+# remove surface and features
+\rm -f constant/triSurface/motorBike.obj.gz > /dev/null 2>&1
+\rm -rf constant/extendedFeatureEdgeMesh > /dev/null 2>&1
+\rm -f constant/triSurface/motorBike.eMesh > /dev/null 2>&1
+
+rm -rf 0 > /dev/null 2>&1
+
+cleanCase
+
+\rm -f constant/polyMesh/boundary
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun
new file mode 100755
index 0000000000..a3eae2016b
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun
@@ -0,0 +1,15 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+./Allrun.pre
+
+#runApplication `getApplication`
+runParallel `getApplication` 5
+runApplication reconstructParMesh -latestTime
+runApplication reconstructPar -latestTime
+
+
+# ----------------------------------------------------------------- end-of-file
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun.pre b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun.pre
new file mode 100755
index 0000000000..a42231557c
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/Allrun.pre
@@ -0,0 +1,27 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+# copy motorbike surface from resources directory
+cp $FOAM_TUTORIALS/resources/geometry/motorBike.obj.gz constant/triSurface/
+
+runApplication surfaceFeatureExtract
+
+runApplication blockMesh
+
+#runApplication snappyHexMesh -overwrite
+#\rm -f constant/polyMesh/refinementHistory*
+# - set the initial fields
+#cp -rf 0.org 0
+#runApplication setFields
+
+runApplication decomposePar -force -cellDist
+runParallel snappyHexMesh 5 -overwrite
+ls -d processor* | xargs -i rm -f ./{}/constant/polyMesh/refinementHistory $1
+
+# - set the initial fields
+ls -d processor* | xargs -i rm -rf ./{}/0 $1
+ls -d processor* | xargs -i cp -r 0.org ./{}/0 $1
+runParallel setFields 5
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/RASProperties b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/RASProperties
new file mode 100644
index 0000000000..3b7dcacf86
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/RASProperties
@@ -0,0 +1,24 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      RASProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+RASModel            kOmegaSST;
+
+turbulence          on;
+
+printCoeffs         on;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/dynamicMeshDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/dynamicMeshDict
new file mode 100644
index 0000000000..9b42c7daa9
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/dynamicMeshDict
@@ -0,0 +1,50 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      dynamicMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh   dynamicRefineFvMesh;
+
+dynamicRefineFvMeshCoeffs
+{
+    // How often to refine
+    refineInterval  1;
+    // Field to be refinement on
+    field           alpha.water;
+    // Refine field inbetween lower..upper
+    lowerRefineLevel 0.001;
+    upperRefineLevel 0.999;
+    // Have slower than 2:1 refinement
+    nBufferLayers   1;
+    // Refine cells only up to maxRefinement levels
+    maxRefinement   3;
+    // Stop refinement if maxCells reached
+    maxCells        2000000;
+    // Flux field and corresponding velocity field. Fluxes on changed
+    // faces get recalculated by interpolating the velocity. Use 'none'
+    // on surfaceScalarFields that do not need to be reinterpolated.
+    correctFluxes
+    (
+        (phi none)
+        (nHatf none)
+        (rhoPhi none)
+        (ghf none)
+    );
+    // Write the refinement level as a volScalarField
+    dumpLevel       true;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/g b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/g
new file mode 100644
index 0000000000..897615a50d
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/g
@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       uniformDimensionedVectorField;
+    location    "constant";
+    object      g;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -2 0 0 0 0];
+value           ( 0 0 -9.81 );
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/polyMesh/blockMeshDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/polyMesh/blockMeshDict
new file mode 100644
index 0000000000..38149564a1
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/polyMesh/blockMeshDict
@@ -0,0 +1,89 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 1;
+
+vertices
+(
+    (-1 -0.5 0)
+    ( 3 -0.5 0)
+    ( 3  0.5 0)
+    (-1  0.5 0)
+    (-1 -0.5 2)
+    ( 3 -0.5 2)
+    ( 3  0.5 2)
+    (-1  0.5 2)
+);
+
+blocks
+(
+    hex (0 1 2 3 4 5 6 7) (8 2 4) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    walls
+    {
+        type wall;
+        faces
+        (
+            (3 7 6 2)
+            (1 5 4 0)
+            (0 4 7 3)
+            (2 6 5 1)
+            (0 3 2 1)
+        );
+    }
+//    inlet
+//    {
+//        type patch;
+//        faces
+//        (
+//            (0 4 7 3)
+//        );
+//    }
+//    outlet
+//    {
+//        type patch;
+//        faces
+//        (
+//            (2 6 5 1)
+//        );
+//    }
+//    lowerWall
+//    {
+//        type wall;
+//        faces
+//        (
+//            (0 3 2 1)
+//        );
+//    }
+    upperWall
+    {
+        type patch;
+        faces
+        (
+            (4 5 6 7)
+        );
+    }
+);
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/transportProperties b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/transportProperties
new file mode 100644
index 0000000000..81106f5ea4
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/transportProperties
@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+phases (water air);
+
+water
+{
+    transportModel  Newtonian;
+    nu              nu [ 0 2 -1 0 0 0 0 ] 1e-06;
+    rho             rho [ 1 -3 0 0 0 0 0 ] 1000;
+    CrossPowerLawCoeffs
+    {
+        nu0             nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
+        nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+        m               m [ 0 0 1 0 0 0 0 ] 1;
+        n               n [ 0 0 0 0 0 0 0 ] 0;
+    }
+
+    BirdCarreauCoeffs
+    {
+        nu0             nu0 [ 0 2 -1 0 0 0 0 ] 0.0142515;
+        nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+        k               k [ 0 0 1 0 0 0 0 ] 99.6;
+        n               n [ 0 0 0 0 0 0 0 ] 0.1003;
+    }
+}
+
+air
+{
+    transportModel  Newtonian;
+    nu              nu [ 0 2 -1 0 0 0 0 ] 1.48e-05;
+    rho             rho [ 1 -3 0 0 0 0 0 ] 1;
+    CrossPowerLawCoeffs
+    {
+        nu0             nu0 [ 0 2 -1 0 0 0 0 ] 1e-06;
+        nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+        m               m [ 0 0 1 0 0 0 0 ] 1;
+        n               n [ 0 0 0 0 0 0 0 ] 0;
+    }
+
+    BirdCarreauCoeffs
+    {
+        nu0             nu0 [ 0 2 -1 0 0 0 0 ] 0.0142515;
+        nuInf           nuInf [ 0 2 -1 0 0 0 0 ] 1e-06;
+        k               k [ 0 0 1 0 0 0 0 ] 99.6;
+        n               n [ 0 0 0 0 0 0 0 ] 0.1003;
+    }
+}
+
+sigma           sigma [ 1 0 -2 0 0 0 0 ] 0.07;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/triSurface/README b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/triSurface/README
new file mode 100644
index 0000000000..de3f29cc01
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/triSurface/README
@@ -0,0 +1,4 @@
+Directory to house tri-surfaces
+
+The Allrun script copies the surface from the $FOAM_TUTORIALS/resources/geometry
+directory
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/turbulenceProperties b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/turbulenceProperties
new file mode 100644
index 0000000000..c2c3b28a1b
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/constant/turbulenceProperties
@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  laminar;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/controlDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/controlDict
new file mode 100644
index 0000000000..72964e844d
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/controlDict
@@ -0,0 +1,60 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//DebugSwitches
+//{
+//    dynamicRefineFvMesh 1;
+//}
+
+application     interDyMFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         2;
+
+deltaT          0.001;
+
+writeControl    adjustableRunTime;
+writeInterval   0.02;
+
+purgeWrite      0;
+
+
+writeFormat     binary;
+
+writePrecision  6;
+
+writeCompression uncompressed;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+adjustTimeStep  yes;
+
+maxCo           0.5;
+maxAlphaCo      0.5;
+maxDeltaT       1;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/decomposeParDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/decomposeParDict
new file mode 100644
index 0000000000..a4296cf289
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/decomposeParDict
@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      decomposeParDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+numberOfSubdomains 5;
+
+method          hierarchical;
+// method          ptscotch;
+
+simpleCoeffs
+{
+    n               (4 1 1);
+    delta           0.001;
+}
+
+hierarchicalCoeffs
+{
+    n               (5 1 1);
+    delta           0.001;
+    order           xyz;
+}
+
+manualCoeffs
+{
+    dataFile        "cellDecomposition";
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSchemes b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSchemes
new file mode 100644
index 0000000000..5055a179c6
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSchemes
@@ -0,0 +1,59 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+}
+
+divSchemes
+{
+    div(rhoPhi,U)   Gauss upwind;
+    div(phi,alpha)  Gauss vanLeer;
+    div(phirb,alpha) Gauss linear;
+    div((muEff*dev(T(grad(U))))) Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear corrected;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         corrected;
+}
+
+fluxRequired
+{
+    default         no;
+    p_rgh;
+    pcorr;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSolution b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSolution
new file mode 100644
index 0000000000..946f2c0215
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/fvSolution
@@ -0,0 +1,83 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    "alpha.water.*"
+    {
+        nAlphaCorr      1;
+        nAlphaSubCycles 3;
+        cAlpha          1;
+    }
+
+    p_rgh
+    {
+        solver          GAMG;
+        tolerance       1e-7;
+        relTol          0.01;
+        smoother        DIC;
+        nPreSweeps      0;
+        nPostSweeps     2;
+        nFinestSweeps   2;
+        cacheAgglomeration false;
+        nCellsInCoarsestLevel 10;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+    }
+
+    p_rghFinal
+    {
+        $p_rgh;
+        relTol          0;
+    }
+
+    "pcorr.*"
+    {
+        $p_rghFinal;
+        tolerance       0.001;
+    }
+
+    U
+    {
+        solver          smoothSolver;
+        smoother        GaussSeidel;
+        tolerance       1e-06;
+        relTol          0;
+        nSweeps         1;
+    }
+
+    "(k|B|nuTilda)"
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-08;
+        relTol          0;
+    }
+}
+
+PIMPLE
+{
+    momentumPredictor no;
+    nCorrectors     3;
+    nNonOrthogonalCorrectors 0;
+
+    pRefPoint      (0.51 0.51 0.51);
+    pRefValue      0;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/meshQualityDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/meshQualityDict
new file mode 100644
index 0000000000..2dbd166629
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/meshQualityDict
@@ -0,0 +1,24 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      meshQualityDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Include defaults parameters from master dictionary
+#include "$WM_PROJECT_DIR/etc/caseDicts/meshQualityDict"
+
+//- minFaceWeight (0 -> 0.5)
+minFaceWeight 0.02;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/setFieldsDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/setFieldsDict
new file mode 100644
index 0000000000..c7cd093635
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/setFieldsDict
@@ -0,0 +1,38 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      setFieldsDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defaultFieldValues
+(
+    volScalarFieldValue alpha.water 0
+    volVectorFieldValue U ( 0 0 0 )
+);
+
+regions
+(
+    boxToCell
+    {
+        //box ( -1 -0.5 0 ) ( -0.5 0.5 2 );
+        box ( -1 -0.5 1.5 ) ( 3 0.5 2 );
+        fieldValues
+        (
+            volScalarFieldValue alpha.water 1
+        );
+    }
+ );
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/snappyHexMeshDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/snappyHexMeshDict
new file mode 100644
index 0000000000..2870897db1
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/snappyHexMeshDict
@@ -0,0 +1,314 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      snappyHexMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Which of the steps to run
+castellatedMesh true;
+snap            true;
+addLayers       true;
+
+
+// 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
+{
+    motorBike.obj
+    {
+        type triSurfaceMesh;
+        name motorBike;
+    }
+};
+
+
+// Optional: avoid patch-face merging. Allows mesh to be used for
+//           refinement/unrefinement
+keepHex true;
+
+
+
+// Settings for the castellatedMesh generation.
+castellatedMeshControls
+{
+
+    // Refinement parameters
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    // If local number of cells is >= maxLocalCells on any processor
+    // switches from from refinement followed by balancing
+    // (current method) to (weighted) balancing before refinement.
+    maxLocalCells 100000;
+
+    // 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.
+    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)
+    minRefinementCells 10;
+
+    // Allow a certain level of imbalance during refining
+    // (since balancing is quite expensive)
+    // Expressed as fraction of perfect balance (= overall number of cells /
+    // nProcs). 0=balance always.
+    maxLoadUnbalance 0.10;
+
+
+    // Number of buffer layers between different levels.
+    // 1 means normal 2:1 refinement restriction, larger means slower
+    // refinement.
+    nCellsBetweenLevels 3;
+
+
+
+    // 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
+    ();
+
+
+
+    // Surface based refinement
+    // ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    // 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.
+
+    refinementSurfaces
+    {
+        motorBike
+        {
+            // Surface-wise min and max refinement level
+            level (3 3);
+
+            // Optional specification of patch type (default is wall). No
+            // constraint types (cyclic, symmetry) etc. are allowed.
+            patchInfo
+            {
+                type wall;
+                inGroups (motorBikeGroup);
+            }
+        }
+    }
+
+    // Resolve sharp angles
+    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
+    {
+    }
+
+
+    // 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 (2.991 0.4991 1.991);
+
+
+    // Whether any faceZones (as specified in the refinementSurfaces)
+    // are only on the boundary of corresponding cellZones or also allow
+    // free-standing zone faces. Not used if there are no faceZones.
+    allowFreeStandingZoneFaces true;
+}
+
+
+
+// Settings for the snapping.
+snapControls
+{
+    //- Number of patch smoothing iterations before finding correspondence
+    //  to surface
+    nSmoothPatch 3;
+
+    //- Relative distance for points to be attracted by surface feature point
+    //  or edge. True distance is this factor times local
+    //  maximum edge length.
+    tolerance 2.0;
+
+    //- Number of mesh displacement relaxation iterations.
+    nSolveIter 30;
+
+    //- Maximum number of snapping relaxation iterations. Should stop
+    //  before upon reaching a correct mesh.
+    nRelaxIter 5;
+
+    // Feature snapping
+
+//        //- Number of feature edge snapping iterations.
+//        //  Leave out altogether to disable.
+//        nFeatureSnapIter 10;
+//
+//        //- Detect (geometric only) features by sampling the surface
+//        //  (default=false).
+//        implicitFeatureSnap false;
+//
+//        //- Use castellatedMeshControls::features (default = true)
+//        explicitFeatureSnap true;
+//
+//        //- Detect points on multiple surfaces (only for explicitFeatureSnap)
+//        multiRegionFeatureSnap false;
+}
+
+
+
+// Settings for the layer addition.
+addLayersControls
+{
+    // Are the thickness parameters below relative to the undistorted
+    // size of the refined cell outside layer (true) or absolute sizes (false).
+    relativeSizes true;
+
+    // Per final patch (so not geometry!) the layer information
+    layers
+    {
+        "motorBike.*"
+        {
+            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.
+    // is the thickness of the layer furthest away from the wall.
+    // See relativeSizes parameter.
+    finalLayerThickness 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.1;
+
+    // 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.
+    // Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
+    nGrow 0;
+
+    // Advanced settings
+
+    // When not to extrude surface. 0 is flat surface, 90 is when two faces
+    // are perpendicular
+    featureAngle 60;
+
+    // At non-patched sides allow mesh to slip if extrusion direction makes
+    // angle larger than slipFeatureAngle.
+    slipFeatureAngle 30;
+
+    // Maximum number of snapping relaxation iterations. Should stop
+    // before upon reaching a correct mesh.
+    nRelaxIter 3;
+
+    // Number of smoothing iterations of surface normals
+    nSmoothSurfaceNormals 1;
+
+    // Number of smoothing iterations of interior mesh movement direction
+    nSmoothNormals 3;
+
+    // Smooth layer thickness over surface patches
+    nSmoothThickness 10;
+
+    // Stop layer growth on highly warped cells
+    maxFaceThicknessRatio 0.5;
+
+    // Reduce layer growth where ratio thickness to medial
+    // distance is large
+    maxThicknessToMedialRatio 0.3;
+
+    // Angle used to pick up medial axis points
+    // Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x.
+    minMedianAxisAngle 90;
+
+
+    // Create buffer region for new layer terminations
+    nBufferCellsNoExtrude 0;
+
+
+    // Overall max number of layer addition iterations. The mesher will exit
+    // if it reaches this number of iterations; possibly with an illegal
+    // mesh.
+    nLayerIter 50;
+}
+
+
+
+// Generic mesh quality settings. At any undoable phase these determine
+// where to undo.
+meshQualityControls
+{
+    #include "meshQualityDict"
+
+
+    // Advanced
+
+    //- Number of error distribution iterations
+    nSmoothScale 4;
+    //- amount to scale back displacement at error points
+    errorReduction 0.75;
+}
+
+
+// Advanced
+
+// Write flags
+writeFlags
+(
+    layerFields     // write volScalarField for layer coverage
+);
+
+
+// Merge tolerance. Is fraction of overall bounding box of initial mesh.
+// Note: the write tolerance needs to be higher than this.
+mergeTolerance 1e-6;
+
+
+// ************************************************************************* //
diff --git a/tutorials/multiphase/interDyMFoam/ras/motorBike/system/surfaceFeatureExtractDict b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/surfaceFeatureExtractDict
new file mode 100644
index 0000000000..fa00f86001
--- /dev/null
+++ b/tutorials/multiphase/interDyMFoam/ras/motorBike/system/surfaceFeatureExtractDict
@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      surfaceFeatureExtractDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+motorBike.obj
+{
+    // How to obtain raw features (extractFromFile || extractFromSurface)
+    extractionMethod    extractFromSurface;
+
+    extractFromSurfaceCoeffs
+    {
+        // Mark edges whose adjacent surface normals are at an angle less
+        // than includedAngle as features
+        // - 0  : selects no edges
+        // - 180: selects all edges
+        includedAngle   150;
+    }
+
+    subsetFeatures
+    {
+        // Keep nonManifold edges (edges with >2 connected faces)
+        nonManifoldEdges       no;
+
+        // Keep open edges (edges with 1 connected face)
+        openEdges       yes;
+    }
+
+
+    // Write options
+
+        // Write features to obj format for postprocessing
+        writeObj                yes;
+}
+
+
+// ************************************************************************* //