From dc43e9152c53cb956baa832aab3a39ae4ddd9464 Mon Sep 17 00:00:00 2001
From: Sandeep Menon <smenon@ecs.umass.edu>
Date: Tue, 17 May 2011 15:31:43 -0400
Subject: [PATCH] Commit details:

 - Added initial support for parallel dynamicTopoFvMesh
 - Conservative remapping support (serial / parallel)
 - Layer addition/removal support (partially tested / not parallel)
 - Dynamic parallel load-balancing support
---
 src/dynamicMesh/dynamicFvMesh/Make/files      |    48 +-
 src/dynamicMesh/dynamicFvMesh/Make/options    |     2 +
 .../dynamicTopoFvMesh/changeMap.H             |   123 +-
 .../dynamicTopoFvMesh/changeMapI.H            |   280 +-
 .../convexSetAlgorithm/cellSetAlgorithm.C     |   470 +
 .../convexSetAlgorithm/cellSetAlgorithm.H     |   128 +
 .../convexSetAlgorithm/convexSetAlgorithm.C   |   565 +
 .../convexSetAlgorithm/convexSetAlgorithm.H   |   198 +
 .../convexSetAlgorithm/faceSetAlgorithm.C     |   415 +
 .../convexSetAlgorithm/faceSetAlgorithm.H     |   128 +
 .../convexSetAlgorithm/tetIntersection.H      |   145 +
 .../convexSetAlgorithm/tetIntersectionI.H     |   387 +
 .../convexSetAlgorithm/triIntersection.H      |   134 +
 .../convexSetAlgorithm/triIntersectionI.H     |   269 +
 .../dynamicTopoFvMesh/coupleMap.C             |   636 +
 .../dynamicTopoFvMesh/coupleMap.H             |   375 +
 .../dynamicTopoFvMesh/coupleMapI.H            |   288 +
 .../dynamicTopoFvMesh/coupledInfo.C           |   648 +
 .../dynamicTopoFvMesh/coupledInfo.H           |   282 +
 .../dynamicTopoFvMesh/dynamicTopoFvMesh.C     |  1902 ++-
 .../dynamicTopoFvMesh/dynamicTopoFvMesh.H     |   386 +-
 .../dynamicTopoFvMeshCheck.C                  |  1284 +-
 .../dynamicTopoFvMeshCoupled.C                | 10088 ++++++++++++++++
 .../dynamicTopoFvMesh/dynamicTopoFvMeshI.H    |   354 +-
 .../dynamicTopoFvMeshMapping.C                |   620 +-
 .../dynamicTopoFvMeshReOrder.C                |   491 +-
 .../dynamicTopoFvMesh/eMesh/eMesh.C           |    27 -
 .../dynamicTopoFvMesh/eMesh/eMesh.H           |    19 -
 .../eMesh/eMeshDemandDrivenData.C             |   191 +-
 .../eMesh/ePatches/ePatch/ePatch.C            |    10 -
 .../eMesh/ePatches/ePatch/ePatch.H            |    12 +-
 .../dynamicTopoFvMesh/edgeBisect.C            |  4154 ++++++-
 .../dynamicTopoFvMesh/edgeCollapse.C          |  5479 +++++++--
 .../dynamicTopoFvMesh/edgeSwap.C              |  1695 ++-
 .../fieldMapping/conservativeMapFields.H      |   150 +
 .../fieldMapping/fluxCorrector.C              |     2 +-
 .../fieldMapping/fluxCorrector.H              |     6 -
 .../fieldMapping/topoCellMapper.C             |   112 +-
 .../fieldMapping/topoCellMapper.H             |    13 +-
 .../fieldMapping/topoCellMapperTemplates.C    |   112 +
 .../fieldMapping/topoMapper.C                 |   473 +-
 .../fieldMapping/topoMapper.H                 |    95 +-
 .../fieldMapping/topoMapperTemplates.C        |   106 +
 .../fieldMapping/topoPatchMapper.C            |   301 +-
 .../fieldMapping/topoPatchMapper.H            |    26 +-
 .../fieldMapping/topoPatchMapperTemplates.C   |    52 +
 .../fieldMapping/topoSurfaceMapper.C          |    72 +-
 .../fieldMapping/topoSurfaceMapper.H          |    12 +-
 .../fieldMapping/topoSurfaceMapperTemplates.C |    89 +
 .../dynamicFvMesh/dynamicTopoFvMesh/meshOps.C |   773 +-
 .../dynamicFvMesh/dynamicTopoFvMesh/meshOps.H |   120 +-
 .../dynamicTopoFvMesh/meshOpsI.H              |   328 +-
 52 files changed, 30104 insertions(+), 4971 deletions(-)
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersection.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersectionI.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersection.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersectionI.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapperTemplates.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
 create mode 100644 src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapperTemplates.C

diff --git a/src/dynamicMesh/dynamicFvMesh/Make/files b/src/dynamicMesh/dynamicFvMesh/Make/files
index faa821822..2822447f5 100644
--- a/src/dynamicMesh/dynamicFvMesh/Make/files
+++ b/src/dynamicMesh/dynamicFvMesh/Make/files
@@ -20,6 +20,38 @@ $(solidBodyMotionFunctions)/translation/translation.C
 mixerGgiFvMesh/mixerGgiFvMesh.C
 turboFvMesh/turboFvMesh.C
 
+eMesh = dynamicTopoFvMesh/eMesh
+$(eMesh)/eMesh.C
+$(eMesh)/eMeshDemandDrivenData.C
+$(eMesh)/eBoundaryMesh/eBoundaryMesh.C
+
+ePatches = $(eMesh)/ePatches
+$(ePatches)/ePatch/ePatch.C
+$(ePatches)/ePatch/newEPatch.C
+
+dynamicTopoFvMesh/dynamicTopoFvMesh.C
+dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
+dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
+dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
+dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
+dynamicTopoFvMesh/edgeSwap.C
+dynamicTopoFvMesh/edgeBisect.C
+dynamicTopoFvMesh/edgeCollapse.C
+
+dynamicTopoFvMesh/coupleMap.C
+
+convexSetAlgorithm = dynamicTopoFvMesh/convexSetAlgorithm
+$(convexSetAlgorithm)/convexSetAlgorithm.C
+$(convexSetAlgorithm)/faceSetAlgorithm.C
+$(convexSetAlgorithm)/cellSetAlgorithm.C
+
+fieldMapping = dynamicTopoFvMesh/fieldMapping
+$(fieldMapping)/topoMapper.C
+$(fieldMapping)/fluxCorrector.C
+$(fieldMapping)/topoCellMapper.C
+$(fieldMapping)/topoPatchMapper.C
+$(fieldMapping)/topoSurfaceMapper.C
+
 tetMetrics = dynamicTopoFvMesh/tetMetrics
 $(tetMetrics)/tetMetric.C
 $(tetMetrics)/tetMetrics.C
@@ -27,20 +59,4 @@ $(tetMetrics)/tetMetrics.C
 lengthScaleEstimator = dynamicTopoFvMesh/lengthScaleEstimator
 $(lengthScaleEstimator)/lengthScaleEstimator.C
 
-eMesh = dynamicTopoFvMesh/eMesh
-$(eMesh)/eMesh.C
-$(eMesh)/eMeshDemandDrivenData.C
-$(eMesh)/eBoundaryMesh/eBoundaryMesh.C
-ePatches = $(eMesh)/ePatches
-$(ePatches)/ePatch/ePatch.C
-$(ePatches)/ePatch/newEPatch.C
-dynamicTopoFvMesh/meshOps.C
-dynamicTopoFvMesh/dynamicTopoFvMesh.C
-dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
-dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
-dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
-dynamicTopoFvMesh/edgeSwap.C
-dynamicTopoFvMesh/edgeBisect.C
-dynamicTopoFvMesh/edgeCollapse.C
-
 LIB = $(FOAM_LIBBIN)/libdynamicFvMesh
diff --git a/src/dynamicMesh/dynamicFvMesh/Make/options b/src/dynamicMesh/dynamicFvMesh/Make/options
index b1a1bbb54..5045edc20 100644
--- a/src/dynamicMesh/dynamicFvMesh/Make/options
+++ b/src/dynamicMesh/dynamicFvMesh/Make/options
@@ -3,6 +3,7 @@ EXE_INC = \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \
     -I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \
     $(WM_DECOMP_INC) \
@@ -15,6 +16,7 @@ LIB_LIBS = \
     -lmeshTools \
     -ldynamicMesh \
     -lfiniteVolume \
+    -ldecompositionMethods \
     $(WM_DECOMP_LIBS) \
     -lfvMotionSolver \
     -lRBFMotionSolver \
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H
index a66e17efc..f23754d0e 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H
@@ -41,109 +41,140 @@ SourceFiles
 #ifndef changeMap_H
 #define changeMap_H
 
+#include "objectMap.H"
 #include "labelList.H"
-#include "FixedList.H"
+#include "dictionary.H"
+#include "DynamicList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
+// Class forward declarations
+class changeMap;
+
+// * * * * * * * * Forward declaration of friend fuctions  * * * * * * * * * //
+
+Ostream& operator<<(Ostream&, const changeMap&);
+
+
 /*---------------------------------------------------------------------------*\
                            Class changeMap Declaration
 \*---------------------------------------------------------------------------*/
 
 class changeMap
+:
+    public dictionary
 {
-    // Sliver type index.
-    //  Type 1: Sliver
-    //  Type 2: Cap
-    //  Type 3: Spade
-    //  Type 4: Wedge
+    // Entity index
+    label index_;
+
+    // Coupled patch index
+    label pIndex_;
+
+    // Type
     label type_;
 
-    // Data specific to sliver-type cells
-    label firstEdge_;
-    label secondEdge_;
-
-    // Data specific to cap-type cells
-    label apexPoint_;
-    label opposingFace_;
-
     // Entities that were added during the operation.
-    //  - Add a master mapping for slaves.
-    //  - Masters get a map of -1.
-    List<FixedList<label,2> > addedPoints_;
-    List<FixedList<label,2> > addedEdges_;
-    List<FixedList<label,2> > addedFaces_;
-    List<FixedList<label,2> > addedCells_;
+    DynamicList<objectMap> addedPoints_;
+    DynamicList<objectMap> addedEdges_;
+    DynamicList<objectMap> addedFaces_;
+    DynamicList<objectMap> addedCells_;
+
+    // Entities that were removed during the operation
+    DynamicList<label> removedPoints_;
+    DynamicList<label> removedEdges_;
+    DynamicList<label> removedFaces_;
+    DynamicList<label> removedCells_;
 
 public:
 
     // Constructor
     changeMap()
     :
+        index_(-1),
+        pIndex_(-1),
         type_(-1),
-        firstEdge_(-1),
-        secondEdge_(-1),
-        apexPoint_(-1),
-        opposingFace_(-1),
-        addedPoints_(0),
-        addedEdges_(0),
-        addedFaces_(0),
-        addedCells_(0)
+        addedPoints_(5),
+        addedEdges_(5),
+        addedFaces_(5),
+        addedCells_(5),
+        removedPoints_(5),
+        removedEdges_(5),
+        removedFaces_(5),
+        removedCells_(5)
     {}
 
     //- Access
 
+        // Entity index
+        inline label& index();
+        inline label index() const;
+
+        // Coupled patch index
+        inline label& patchIndex();
+        inline label patchIndex() const;
+
         // Type
         inline label& type();
         inline label type() const;
 
-        // For sliver-type cells, opposite edges
-        // are identified for removal.
-        inline label& firstEdge();
-        inline label& secondEdge();
-
-        // For cap-type cells, the face requiring splitting
-        // is identified for removal.
-        inline label& apexPoint();
-        inline label& opposingFace();
-
         // Added entities
         inline void addPoint
         (
             const label pIndex,
-            const label master = -1
+            const labelList& master = labelList()
         );
 
         inline void addEdge
         (
             const label eIndex,
-            const label master = -1
+            const labelList& master = labelList()
         );
 
         inline void addFace
         (
             const label fIndex,
-            const label master = -1
+            const labelList& master = labelList()
         );
 
         inline void addCell
         (
             const label cIndex,
-            const label master = -1
+            const labelList& master = labelList()
         );
 
         // Return the list of added entities
-        inline const List<FixedList<label,2> >& addedPointList() const;
-        inline const List<FixedList<label,2> >& addedEdgeList() const;
-        inline const List<FixedList<label,2> >& addedFaceList() const;
-        inline const List<FixedList<label,2> >& addedCellList() const;
+        inline const List<objectMap>& addedPointList() const;
+        inline const List<objectMap>& addedEdgeList() const;
+        inline const List<objectMap>& addedFaceList() const;
+        inline const List<objectMap>& addedCellList() const;
+
+        // Removed entities
+        inline void removePoint(const label pIndex);
+        inline void removeEdge(const label eIndex);
+        inline void removeFace(const label fIndex);
+        inline void removeCell(const label cIndex);
+
+        // Return the list of removed entities
+        inline const labelList& removedPointList() const;
+        inline const labelList& removedEdgeList() const;
+        inline const labelList& removedFaceList() const;
+        inline const labelList& removedCellList() const;
+
+    //- Edit
+
+        // Clear existing lists
+        inline void clear();
 
     //- Operators
 
         inline void operator=(const changeMap& rhs);
+
+    //- IOstream Operators
+
+        inline friend Ostream& operator<<(Ostream&, const changeMap&);
 };
 
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H
index a0a5ed875..54e0f7615 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H
@@ -22,6 +22,17 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
+Class
+    changeMap
+
+Description
+    Accumulate topology change statistics
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
 \*---------------------------------------------------------------------------*/
 
 namespace Foam
@@ -29,6 +40,32 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+// Entity index
+inline label& changeMap::index()
+{
+    return index_;
+}
+
+
+inline label changeMap::index() const
+{
+    return index_;
+}
+
+
+// Coupled patch index
+inline label& changeMap::patchIndex()
+{
+    return pIndex_;
+}
+
+
+inline label changeMap::patchIndex() const
+{
+    return pIndex_;
+}
+
+
 // Type
 inline label& changeMap::type()
 {
@@ -42,140 +79,241 @@ inline label changeMap::type() const
 }
 
 
-// For sliver-type cells, opposite edges
-// are identified for removal.
-inline label& changeMap::firstEdge()
-{
-    return firstEdge_;
-}
-
-
-inline label& changeMap::secondEdge()
-{
-    return secondEdge_;
-}
-
-
-// For cap-type cells, the face requiring splitting
-// is identified for removal.
-inline label& changeMap::apexPoint()
-{
-    return apexPoint_;
-}
-
-
-inline label& changeMap::opposingFace()
-{
-    return opposingFace_;
-}
-
-
-// Added entities
 inline void changeMap::addPoint
 (
     const label pIndex,
-    const label master
+    const labelList& master
 )
 {
-    label curSize = addedPoints_.size();
-
-    addedPoints_.setSize(curSize + 1);
-
-    addedPoints_[curSize][0] = pIndex;
-    addedPoints_[curSize][1] = master;
+    addedPoints_.append(objectMap(pIndex, master));
 }
 
 
 inline void changeMap::addEdge
 (
     const label eIndex,
-    const label master
+    const labelList& master
 )
 {
-    label curSize = addedEdges_.size();
-
-    addedEdges_.setSize(curSize + 1);
-
-    addedEdges_[curSize][0] = eIndex;
-    addedEdges_[curSize][1] = master;
+    addedEdges_.append(objectMap(eIndex, master));
 }
 
 
 inline void changeMap::addFace
 (
     const label fIndex,
-    const label master
+    const labelList& master
 )
 {
-    label curSize = addedFaces_.size();
-
-    addedFaces_.setSize(curSize + 1);
-
-    addedFaces_[curSize][0] = fIndex;
-    addedFaces_[curSize][1] = master;
+    addedFaces_.append(objectMap(fIndex, master));
 }
 
 
 inline void changeMap::addCell
 (
     const label cIndex,
-    const label master
+    const labelList& master
 )
 {
-    label curSize = addedCells_.size();
-
-    addedCells_.setSize(curSize + 1);
-
-    addedCells_[curSize][0] = cIndex;
-    addedCells_[curSize][1] = master;
+    addedCells_.append(objectMap(cIndex, master));
 }
 
 
-// Return an added point
-inline const List<FixedList<label,2> >&
+inline const List<objectMap>&
 changeMap::addedPointList() const
 {
     return addedPoints_;
 }
 
 
-// Return the list of added entities
-inline const List<FixedList<label,2> >&
+inline const List<objectMap>&
 changeMap::addedEdgeList() const
 {
     return addedEdges_;
 }
 
 
-inline const List<FixedList<label,2> >&
+inline const List<objectMap>&
 changeMap::addedFaceList() const
 {
     return addedFaces_;
 }
 
 
-inline const List<FixedList<label,2> >&
+inline const List<objectMap>&
 changeMap::addedCellList() const
 {
     return addedCells_;
 }
 
 
+inline void changeMap::removePoint(const label pIndex)
+{
+    removedPoints_.append(pIndex);
+}
+
+
+inline void changeMap::removeEdge(const label eIndex)
+{
+    removedEdges_.append(eIndex);
+}
+
+
+inline void changeMap::removeFace(const label fIndex)
+{
+    removedFaces_.append(fIndex);
+}
+
+
+inline void changeMap::removeCell(const label cIndex)
+{
+    removedCells_.append(cIndex);
+}
+
+
+inline const labelList&
+changeMap::removedPointList() const
+{
+    return removedPoints_;
+}
+
+
+inline const labelList&
+changeMap::removedEdgeList() const
+{
+    return removedEdges_;
+}
+
+
+inline const labelList&
+changeMap::removedFaceList() const
+{
+    return removedFaces_;
+}
+
+
+inline const labelList&
+changeMap::removedCellList() const
+{
+    return removedCells_;
+}
+
+
+// Clear existing lists
+inline void changeMap::clear()
+{
+    // Clear base dictionary
+    dictionary::clear();
+
+    index_ = -1;
+    pIndex_ = -1;
+
+    type_ = -1;
+
+    // Clear added entities
+    addedPoints_.clear();
+    addedEdges_.clear();
+    addedFaces_.clear();
+    addedCells_.clear();
+
+    // Clear removed entities
+    removedPoints_.clear();
+    removedEdges_.clear();
+    removedFaces_.clear();
+    removedCells_.clear();
+}
+
+
 inline void changeMap::operator=(const changeMap& rhs)
 {
+    // Copy base dictionary
+    dictionary::operator=(rhs);
+
+    index_ = rhs.index_;
+    pIndex_ = rhs.pIndex_;
+
     type_ = rhs.type_;
 
-    firstEdge_    = rhs.firstEdge_;
-    secondEdge_   = rhs.secondEdge_;
-    apexPoint_    = rhs.apexPoint_;
-    opposingFace_ = rhs.opposingFace_;
+    // Copy maps
+    addedPoints_.setSize(rhs.addedPoints_.size());
 
-    addedPoints_  = rhs.addedPoints_;
-    addedEdges_   = rhs.addedEdges_;
-    addedFaces_   = rhs.addedFaces_;
-    addedCells_   = rhs.addedCells_;
+    forAll(addedPoints_, indexI)
+    {
+        addedPoints_[indexI].index() = rhs.addedPoints_[indexI].index();
+
+        addedPoints_[indexI].masterObjects() =
+        (
+            rhs.addedPoints_[indexI].masterObjects()
+        );
+    }
+
+    addedEdges_.setSize(rhs.addedEdges_.size());
+
+    forAll(addedEdges_, indexI)
+    {
+        addedEdges_[indexI].index() = rhs.addedEdges_[indexI].index();
+
+        addedEdges_[indexI].masterObjects() =
+        (
+            rhs.addedEdges_[indexI].masterObjects()
+        );
+    }
+
+    addedFaces_.setSize(rhs.addedFaces_.size());
+
+    forAll(addedFaces_, indexI)
+    {
+        addedFaces_[indexI].index() = rhs.addedFaces_[indexI].index();
+
+        addedFaces_[indexI].masterObjects() =
+        (
+            rhs.addedFaces_[indexI].masterObjects()
+        );
+    }
+
+    addedCells_.setSize(rhs.addedCells_.size());
+
+    forAll(addedCells_, indexI)
+    {
+        addedCells_[indexI].index() = rhs.addedCells_[indexI].index();
+
+        addedCells_[indexI].masterObjects() =
+        (
+            rhs.addedCells_[indexI].masterObjects()
+        );
+    }
+
+    removedPoints_ = rhs.removedPoints_;
+    removedEdges_ = rhs.removedEdges_;
+    removedFaces_ = rhs.removedFaces_;
+    removedCells_ = rhs.removedCells_;
 }
 
+
+inline Ostream& operator<<(Ostream& os, const changeMap& cm)
+{
+    // Write base dictionary
+    os << static_cast<const dictionary&>(cm) << endl;
+
+    os << " index: " << cm.index_ << nl
+       << " patchIndex: " << cm.pIndex_ << nl
+       << " type: " << cm.type_ << nl
+       << " addedPoints: " << cm.addedPoints_ << nl
+       << " addedEdges: " << cm.addedEdges_ << nl
+       << " addedFaces: " << cm.addedFaces_ << nl
+       << " addedCells: " << cm.addedCells_ << nl
+       << " removedPoints: " << cm.removedPoints_ << nl
+       << " removedEdges: " << cm.removedEdges_ << nl
+       << " removedFaces: " << cm.removedFaces_ << nl
+       << " removedCells: " << cm.removedCells_ << endl;
+
+    // Check state of IOstream
+    os.check("Ostream& operator<<(Ostream&, changeMap&)");
+
+    return os;
+}
+
+
 } // End namespace Foam
 
 // ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.C
new file mode 100644
index 000000000..fd3c0dc30
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.C
@@ -0,0 +1,470 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    cellSetAlgorithm
+
+Description
+    Class for convexSetAlgorithms pertaining to cells
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSetAlgorithm.H"
+
+#include "meshOps.H"
+#include "triFace.H"
+#include "polyMesh.H"
+#include "tetIntersection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+cellSetAlgorithm::cellSetAlgorithm
+(
+    const polyMesh& mesh,
+    const pointField& newPoints,
+    const UList<edge>& newEdges,
+    const UList<face>& newFaces,
+    const UList<cell>& newCells,
+    const UList<label>& newOwner,
+    const UList<label>& newNeighbour
+)
+:
+    convexSetAlgorithm
+    (
+        mesh,
+        newPoints,
+        newEdges,
+        newFaces,
+        newCells,
+        newOwner,
+        newNeighbour
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void cellSetAlgorithm::computeNormFactor(const label index) const
+{
+    // Clear existing fields
+    parents_.clear();
+
+    centres_.clear();
+    weights_.clear();
+
+    // Compute volume / centre (using refNorm_ as centre)
+    meshOps::cellCentreAndVolume
+    (
+        index,
+        newPoints_,
+        newFaces_,
+        newCells_,
+        newOwner_,
+        refNorm_,
+        normFactor_
+    );
+
+    // Compute a bounding box around the cell
+    box_ = boundBox(newCells_[index].points(newFaces_, newPoints_), false);
+
+    vector minToXb = (box_.min() - box_.midpoint());
+    vector maxToXb = (box_.max() - box_.midpoint());
+
+    // Scale it by a bit
+    box_.min() += (1.5 * minToXb);
+    box_.max() += (1.5 * maxToXb);
+}
+
+
+// Check whether the bounding box contains the entity
+bool cellSetAlgorithm::contains(const label index) const
+{
+    // Fetch old points
+    const labelListList& cellPoints = mesh_.cellPoints();
+    const labelList& checkCell = cellPoints[index];
+
+    // Check if the bounding box contains any of the supplied points
+    forAll(checkCell, pointI)
+    {
+        if (box_.contains(mesh_.points()[checkCell[pointI]]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+// Compute intersection
+bool cellSetAlgorithm::computeIntersection
+(
+    const label newIndex,
+    const label oldIndex,
+    const label offset,
+    bool output
+) const
+{
+    bool intersects = false;
+
+    const pointField& newPoints = newPoints_;
+    const pointField& oldPoints = mesh_.points();
+
+    const cell& newCell = newCells_[newIndex];
+    const cell& oldCell = mesh_.cells()[oldIndex];
+
+    // Check if decomposition is necessary
+    if (oldCell.size() > 4 || newCell.size() > 4)
+    {
+        // Decompose new / old cells
+        DynamicList<FixedList<point, 4> > clippingTets(15);
+        DynamicList<FixedList<point, 4> > subjectTets(15);
+
+        label ntOld = 0, ntNew = 0;
+        vector oldCentre = vector::zero, newCentre = vector::zero;
+
+        // Configure tets from oldCell
+        forAll(oldCell, faceI)
+        {
+            const face& oldFace = mesh_.faces()[oldCell[faceI]];
+
+            vector fCentre = oldFace.centre(oldPoints);
+
+            if (oldFace.size() == 3)
+            {
+                // Add a new entry
+                subjectTets.append(FixedList<point, 4>(vector::zero));
+
+                subjectTets[ntOld][0] = oldPoints[oldFace[0]];
+                subjectTets[ntOld][1] = oldPoints[oldFace[1]];
+                subjectTets[ntOld][2] = oldPoints[oldFace[2]];
+
+                ntOld++;
+            }
+            else
+            {
+                forAll(oldFace, pI)
+                {
+                    // Add a new entry
+                    subjectTets.append(FixedList<point, 4>(vector::zero));
+
+                    subjectTets[ntOld][0] = oldPoints[oldFace[pI]];
+                    subjectTets[ntOld][1] = oldPoints[oldFace.nextLabel(pI)];
+                    subjectTets[ntOld][2] = fCentre;
+
+                    ntOld++;
+                }
+            }
+
+            oldCentre += fCentre;
+        }
+
+        // Configure tets from newCell
+        forAll(newCell, faceI)
+        {
+            const face& newFace = newFaces_[newCell[faceI]];
+
+            vector fCentre = newFace.centre(newPoints);
+
+            if (newFace.size() == 3)
+            {
+                // Add a new entry
+                clippingTets.append(FixedList<point, 4>(vector::zero));
+
+                clippingTets[ntNew][0] = newPoints[newFace[0]];
+                clippingTets[ntNew][1] = newPoints[newFace[1]];
+                clippingTets[ntNew][2] = newPoints[newFace[2]];
+
+                ntNew++;
+            }
+            else
+            {
+                forAll(newFace, pI)
+                {
+                    // Add a new entry
+                    clippingTets.append(FixedList<point, 4>(vector::zero));
+
+                    clippingTets[ntNew][0] = newPoints[newFace[pI]];
+                    clippingTets[ntNew][1] = newPoints[newFace.nextLabel(pI)];
+                    clippingTets[ntNew][2] = fCentre;
+
+                    ntNew++;
+                }
+            }
+
+            newCentre += fCentre;
+        }
+
+        oldCentre /= oldCell.size();
+        newCentre /= newCell.size();
+
+        // Fill-in last points for all tets
+        forAll(subjectTets, i)
+        {
+            subjectTets[i][3] = oldCentre;
+        }
+
+        forAll(clippingTets, i)
+        {
+            clippingTets[i][3] = newCentre;
+        }
+
+        // Accumulate volume / centroid over all intersections
+        bool foundIntersect = false;
+
+        scalar totalVolume = 0.0;
+        vector totalCentre = vector::zero;
+
+        // Loop through all clipping tets
+        forAll(clippingTets, i)
+        {
+            // Initialize the intersector
+            tetIntersection intersector(clippingTets[i]);
+
+            // Test for intersection and evaluate
+            // against all subject tets
+            forAll(subjectTets, j)
+            {
+                intersects = intersector.evaluate(subjectTets[j]);
+
+                if (intersects)
+                {
+                    scalar volume = 0.0;
+                    vector centre = vector::zero;
+
+                    // Fetch volume and centre
+                    intersector.getVolumeAndCentre(volume, centre);
+
+                    // Accumulate volume / centroid
+                    totalVolume += volume;
+                    totalCentre += (volume * centre);
+
+                    foundIntersect = true;
+
+                    if (output)
+                    {
+                        writeVTK
+                        (
+                            "polyhedronIntersect_"
+                          + Foam::name(newIndex)
+                          + '_'
+                          + Foam::name(oldIndex)
+                          + '_' + Foam::name(i)
+                          + '_' + Foam::name(j),
+                            intersector.getIntersection()
+                        );
+                    }
+                }
+            }
+        }
+
+        // Size-up the internal lists
+        if (foundIntersect && !output)
+        {
+            // Normalize centre
+            totalCentre /= totalVolume + VSMALL;
+
+            // Normalize and check if this is worth it
+            if (mag(totalVolume/normFactor_) > SMALL)
+            {
+                // Size-up the internal lists
+                meshOps::sizeUpList((oldIndex - offset), parents_);
+                meshOps::sizeUpList(totalVolume, weights_);
+                meshOps::sizeUpList(totalCentre, centres_);
+
+                intersects = true;
+            }
+            else
+            {
+                intersects = false;
+            }
+        }
+    }
+    else
+    {
+        // Configure points for clipping tetrahedron
+        FixedList<point, 4> clippingTet(vector::zero);
+
+        // Configure the clipping tetrahedron.
+        const face& firstNewFace = newFaces_[newCell[0]];
+        const face& secondNewFace = newFaces_[newCell[1]];
+
+        // Find the isolated point
+        label fourthNewPoint =
+        (
+            meshOps::findIsolatedPoint
+            (
+                firstNewFace,
+                secondNewFace
+            )
+        );
+
+        // Fill in points
+        clippingTet[0] = newPoints[firstNewFace[0]];
+        clippingTet[1] = newPoints[firstNewFace[1]];
+        clippingTet[2] = newPoints[firstNewFace[2]];
+        clippingTet[3] = newPoints[fourthNewPoint];
+
+        // Configure points for subject tetrahedron
+        FixedList<point, 4> subjectTet(vector::zero);
+
+        // Configure the subject tetrahedron.
+        const face& firstOldFace = mesh_.faces()[oldCell[0]];
+        const face& secondOldFace = mesh_.faces()[oldCell[1]];
+
+        // Find the isolated point
+        label fourthOldPoint =
+        (
+            meshOps::findIsolatedPoint
+            (
+                firstOldFace,
+                secondOldFace
+            )
+        );
+
+        // Fill in points
+        subjectTet[0] = oldPoints[firstOldFace[0]];
+        subjectTet[1] = oldPoints[firstOldFace[1]];
+        subjectTet[2] = oldPoints[firstOldFace[2]];
+        subjectTet[3] = oldPoints[fourthOldPoint];
+
+        // Initialize the intersector
+        tetIntersection intersector(clippingTet);
+
+        // Test for intersection and evaluate
+        intersects = intersector.evaluate(subjectTet);
+
+        if (intersects)
+        {
+            scalar volume = 0.0;
+            vector centre = vector::zero;
+
+            // Fetch volume and centre
+            intersector.getVolumeAndCentre(volume, centre);
+
+            // Normalize and check if this is worth it
+            if (mag(volume/normFactor_) > SMALL)
+            {
+                if (output)
+                {
+                    writeVTK
+                    (
+                        "tetIntersectNew_"
+                      + Foam::name(newIndex),
+                        List<FixedList<point, 4> >(1, clippingTet)
+                    );
+
+                    writeVTK
+                    (
+                        "tetIntersectOld_"
+                      + Foam::name(newIndex)
+                      + '_'
+                      + Foam::name(oldIndex),
+                        List<FixedList<point, 4> >(1, subjectTet)
+                    );
+
+                    writeVTK
+                    (
+                        "tetIntersect_"
+                      + Foam::name(newIndex)
+                      + '_'
+                      + Foam::name(oldIndex),
+                        intersector.getIntersection()
+                    );
+                }
+
+                // Size-up the internal lists
+                meshOps::sizeUpList((oldIndex - offset), parents_);
+                meshOps::sizeUpList(volume, weights_);
+                meshOps::sizeUpList(centre, centres_);
+            }
+            else
+            {
+                intersects = false;
+            }
+        }
+    }
+
+    return intersects;
+}
+
+
+//- Write out tets as a VTK
+void cellSetAlgorithm::writeVTK
+(
+    const word& name,
+    const List<FixedList<point, 4> >& tetList
+) const
+{
+    // Fill up all points
+    label pI = 0;
+
+    List<cell> allTets(tetList.size(), cell(4));
+    pointField allPoints(4 * tetList.size());
+
+    forAll(tetList, tetI)
+    {
+        allTets[tetI][0] = pI;
+        allPoints[pI++] = tetList[tetI][0];
+
+        allTets[tetI][1] = pI;
+        allPoints[pI++] = tetList[tetI][1];
+
+        allTets[tetI][2] = pI;
+        allPoints[pI++] = tetList[tetI][2];
+
+        allTets[tetI][3] = pI;
+        allPoints[pI++] = tetList[tetI][3];
+    }
+
+    // Write out in cell-to-node addressing
+    meshOps::writeVTK
+    (
+        mesh_,
+        name,
+        identity(tetList.size()),
+        3,
+        allPoints,
+        List<edge>(0),
+        List<face>(0),
+        allTets,
+        List<label>(0)
+    );
+}
+
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.H
new file mode 100644
index 000000000..fbf2a4049
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/cellSetAlgorithm.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    cellSetAlgorithm
+
+Description
+    Class for convexSetAlgorithms pertaining to cells
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    cellSetAlgorithm.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSetAlgorithm_H
+#define cellSetAlgorithm_H
+
+#include "convexSetAlgorithm.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class cellSetAlgorithm Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSetAlgorithm
+:
+    public convexSetAlgorithm
+{
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSetAlgorithm(const cellSetAlgorithm&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSetAlgorithm&);
+
+        //- Write out tets as a VTK
+        void writeVTK
+        (
+            const word&,
+            const List<FixedList<point, 4> >&
+        ) const;
+
+public:
+
+    //- Constructor
+
+        cellSetAlgorithm
+        (
+            const polyMesh& mesh,
+            const pointField& newPoints,
+            const UList<edge>& newEdges,
+            const UList<face>& newFaces,
+            const UList<cell>& newCells,
+            const UList<label>& newOwner,
+            const UList<label>& newNeighbour
+        );
+
+    //- Destructor
+
+        virtual ~cellSetAlgorithm()
+        {}
+
+    //- Virtual member functions
+
+        // Dimensions of the algorithm
+        virtual label dimension() const
+        {
+            return 3;
+        }
+
+        // Compute normFactor
+        virtual void computeNormFactor(const label index) const;
+
+        // Check whether the bounding box contains the entity
+        virtual bool contains(const label index) const;
+
+        // Compute intersections
+        virtual bool computeIntersection
+        (
+            const label newIndex,
+            const label oldIndex,
+            const label offset,
+            bool output
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
new file mode 100644
index 000000000..22b028a5f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
@@ -0,0 +1,565 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    convexSetAlgorithm
+
+Description
+    Base class for convexSetAlgorithms
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "Time.H"
+#include "IOMap.H"
+#include "meshOps.H"
+#include "polyMesh.H"
+#include "objectMap.H"
+#include "edgeIOList.H"
+#include "cellIOList.H"
+
+#include "convexSetAlgorithm.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+convexSetAlgorithm::convexSetAlgorithm
+(
+    const polyMesh& mesh,
+    const pointField& newPoints,
+    const UList<edge>& newEdges,
+    const UList<face>& newFaces,
+    const UList<cell>& newCells,
+    const UList<label>& newOwner,
+    const UList<label>& newNeighbour
+)
+:
+    nOldPoints_(mesh.nPoints()),
+    mesh_(mesh),
+    newPoints_(newPoints),
+    newEdges_(newEdges),
+    newFaces_(newFaces),
+    newCells_(newCells),
+    newOwner_(newOwner),
+    newNeighbour_(newNeighbour)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Obtain map weighting factors
+void convexSetAlgorithm::computeWeights
+(
+    const label index,
+    const label offset,
+    const labelList& mapCandidates,
+    const labelListList& oldNeighbourList,
+    labelList& parents,
+    scalarField& weights,
+    vectorField& centres,
+    bool output
+)
+{
+    if (parents.size() || weights.size() || centres.size())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "void convexSetAlgorithm::computeWeights\n"
+            "(\n"
+            "    const label index,\n"
+            "    const label offset,\n"
+            "    const labelList& mapCandidates,\n"
+            "    const labelListList& oldNeighbourList,\n"
+            "    labelList& parents,\n"
+            "    scalarField& weights,\n"
+            "    vectorField& centres,\n"
+            "    bool output\n"
+            ")\n"
+        )
+            << " Addressing has already been calculated." << nl
+            << " Index: " << index << nl
+            << " Offset: " << offset << nl
+            << " Type: " << (dimension() == 2 ? "Face" : "Cell") << nl
+            << " mapCandidates: " << mapCandidates << nl
+            << " Parents: " << parents << nl
+            << " Weights: " << weights << nl
+            << " Centres: " << centres << nl
+            << abort(FatalError);
+    }
+
+    // Do nothing for empty lists
+    if (mapCandidates.empty() || oldNeighbourList.empty())
+    {
+        return;
+    }
+
+    bool changed;
+    label nAttempts = 0, nIntersects = 0;
+
+    // Calculate the algorithm normFactor
+    computeNormFactor(index);
+
+    // Maintain a check-list
+    labelHashSet checked, skipped;
+
+    // Loop and add intersections until nothing changes
+    do
+    {
+        // Reset flag
+        changed = false;
+
+        // Fetch the set of candidates
+        labelList checkList;
+
+        if (nAttempts == 0)
+        {
+            checkList = mapCandidates;
+        }
+        else
+        {
+            checkList = checked.toc();
+        }
+
+        forAll(checkList, indexI)
+        {
+            labelList checkEntities;
+
+            if (nAttempts == 0)
+            {
+                checkEntities = labelList(1, checkList[indexI] - offset);
+            }
+            else
+            {
+                checkEntities = oldNeighbourList[checkList[indexI]];
+            }
+
+            forAll(checkEntities, entityI)
+            {
+                label checkEntity = checkEntities[entityI];
+
+                // Skip if this is already
+                // on the checked / skipped list
+                if
+                (
+                    (checked.found(checkEntity)) ||
+                    (skipped.found(checkEntity))
+                )
+                {
+                    continue;
+                }
+
+                bool intersect =
+                (
+                    computeIntersection
+                    (
+                        index,
+                        checkEntity + offset,
+                        offset,
+                        output
+                    )
+                );
+
+                if (intersect)
+                {
+                    nIntersects++;
+
+                    if (!checked.found(checkEntity))
+                    {
+                        checked.insert(checkEntity);
+                    }
+
+                    changed = true;
+                }
+                else
+                {
+                    // Add to the skipped list
+                    if (!skipped.found(checkEntity))
+                    {
+                        skipped.insert(checkEntity);
+                    }
+                }
+            }
+        }
+
+        if (nAttempts == 0 && !changed)
+        {
+            // Need to setup a rescue mechanism.
+            labelHashSet rescue;
+
+            forAll(mapCandidates, cI)
+            {
+                if (!rescue.found(mapCandidates[cI] - offset))
+                {
+                    rescue.insert(mapCandidates[cI] - offset);
+                }
+            }
+
+            for (label level = 0; level < 10; level++)
+            {
+                labelList initList = rescue.toc();
+
+                forAll(initList, fI)
+                {
+                    const labelList& ff = oldNeighbourList[initList[fI]];
+
+                    forAll(ff, entityI)
+                    {
+                        if (!rescue.found(ff[entityI]))
+                        {
+                            rescue.insert(ff[entityI]);
+                        }
+                    }
+                }
+            }
+
+            labelList finalList = rescue.toc();
+
+            forAll(finalList, entityI)
+            {
+                label checkEntity = finalList[entityI];
+
+                bool intersect =
+                (
+                    computeIntersection
+                    (
+                        index,
+                        checkEntity + offset,
+                        offset,
+                        output
+                    )
+                );
+
+                if (intersect)
+                {
+                    nIntersects++;
+
+                    if (!checked.found(checkEntity))
+                    {
+                        checked.insert(checkEntity);
+                    }
+
+                    changed = true;
+                    break;
+                }
+            }
+
+            if (!changed)
+            {
+                // No point in continuing further...
+                break;
+            }
+        }
+
+        nAttempts++;
+
+        // Break out if we're taking too long
+        if (nAttempts > 20)
+        {
+            break;
+        }
+
+    } while (changed);
+
+    // Normalize weights
+    normalize(false);
+
+    // Populate lists
+    populateLists(parents, centres, weights);
+}
+
+
+// Output an entity as a VTK file
+void convexSetAlgorithm::writeVTK
+(
+    const word& name,
+    const label entity,
+    const label primitiveType,
+    const bool useOldConnectivity
+) const
+{
+    writeVTK
+    (
+        name,
+        labelList(1, entity),
+        primitiveType,
+        useOldConnectivity
+    );
+}
+
+
+// Output a list of entities as a VTK file
+void convexSetAlgorithm::writeVTK
+(
+    const word& name,
+    const labelList& cList,
+    const label primitiveType,
+    const bool useOldConnectivity
+) const
+{
+    if (useOldConnectivity)
+    {
+        const polyMesh& mesh = this->mesh_;
+
+        meshOps::writeVTK
+        (
+            mesh,
+            name,
+            cList,
+            primitiveType,
+            mesh.points(),
+            mesh.edges(),
+            mesh.faces(),
+            mesh.cells(),
+            mesh.faceOwner()
+        );
+    }
+    else
+    {
+        meshOps::writeVTK
+        (
+            this->mesh_,
+            name,
+            cList,
+            primitiveType,
+            newPoints_,
+            newEdges_,
+            newFaces_,
+            newCells_,
+            newOwner_
+        );
+    }
+}
+
+
+bool convexSetAlgorithm::consistent(const scalar tolerance) const
+{
+    if (weights_.size())
+    {
+        scalar normError = mag(1.0 - (sum(weights_)/normFactor_));
+
+        if (normError < tolerance)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    return false;
+}
+
+
+// Return the normFactor
+scalar convexSetAlgorithm::normFactor() const
+{
+    return normFactor_;
+}
+
+
+// Normalize stored weights
+void convexSetAlgorithm::normalize(bool normSum) const
+{
+    if (normSum)
+    {
+        if (weights_.size())
+        {
+            weights_ /= sum(weights_);
+        }
+    }
+    else
+    {
+        if (weights_.size())
+        {
+            weights_ /= normFactor_;
+        }
+    }
+}
+
+
+// Extract weights and centres to lists
+void convexSetAlgorithm::populateLists
+(
+    labelList& parents,
+    vectorField& centres,
+    scalarField& weights
+) const
+{
+    // Clear inputs
+    parents.clear();
+    centres.clear();
+    weights.clear();
+
+    if (weights_.size())
+    {
+        parents = parents_;
+        centres = centres_;
+        weights = weights_;
+    }
+}
+
+
+// Write out connectivity information to disk
+bool convexSetAlgorithm::write() const
+{
+    pointIOField
+    (
+        IOobject
+        (
+            "newPoints",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newPoints_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    edgeIOList
+    (
+        IOobject
+        (
+            "newEdges",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newEdges_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    faceIOList
+    (
+        IOobject
+        (
+            "newFaces",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newFaces_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    cellIOList
+    (
+        IOobject
+        (
+            "newCells",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newCells_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    labelIOList
+    (
+        IOobject
+        (
+            "newOwner",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newOwner_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    labelIOList
+    (
+        IOobject
+        (
+            "newNeighbour",
+            mesh_.time().timeName(),
+            "convexSetAlgorithm",
+            mesh_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        newNeighbour_
+    ).writeObject
+    (
+        IOstream::BINARY,
+        IOstream::currentVersion,
+        IOstream::COMPRESSED
+    );
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.H
new file mode 100644
index 000000000..e134a83c0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.H
@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    convexSetAlgorithm
+
+Description
+    Base class for convexSetAlgorithms
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    convexSetAlgorithm.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef convexSetAlgorithm_H
+#define convexSetAlgorithm_H
+
+#include "Map.H"
+#include "label.H"
+#include "edgeList.H"
+#include "faceList.H"
+#include "cellList.H"
+#include "boundBox.H"
+#include "objectMap.H"
+#include "vectorField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                    Class convexSetAlgorithm Declaration
+\*---------------------------------------------------------------------------*/
+
+class convexSetAlgorithm
+{
+
+protected:
+
+    // Protected data
+
+        const label nOldPoints_;
+
+        //- References to old-level connectivity
+        //  [Before topo-changes, at old point-positions]
+        const polyMesh& mesh_;
+
+        //- References to new-level connectivity
+        //  [After topo-changes, at old point-positions]
+        const pointField& newPoints_;
+        const UList<edge>& newEdges_;
+        const UList<face>& newFaces_;
+        const UList<cell>& newCells_;
+        const UList<label>& newOwner_;
+        const UList<label>& newNeighbour_;
+
+        //- Entity parents
+        mutable labelList parents_;
+
+        //- Internal data members
+        mutable boundBox box_;
+        mutable vector refNorm_;
+        mutable scalar normFactor_;
+        mutable vectorField centres_;
+        mutable scalarField weights_;
+
+public:
+
+    //- Constructor
+
+        // Construct from components
+        convexSetAlgorithm
+        (
+            const polyMesh& mesh,
+            const pointField& newPoints,
+            const UList<edge>& newEdges,
+            const UList<face>& newFaces,
+            const UList<cell>& newCells,
+            const UList<label>& newOwner,
+            const UList<label>& newNeighbour
+        );
+
+    //- Destructor
+
+        virtual ~convexSetAlgorithm()
+        {}
+
+    //- Member functions
+
+        // Dimensions of the algorithm
+        virtual label dimension() const = 0;
+
+        // Return true if accumulated weights are consistent
+        virtual bool consistent(const scalar tolerance) const;
+
+        // Return the normFactor
+        virtual scalar normFactor() const;
+
+        // Normalize stored weights
+        virtual void normalize(bool normSum) const;
+
+        // Check whether the bounding box contains the entity
+        virtual bool contains(const label index) const = 0;
+
+        // Extract weights and centres to lists
+        virtual void populateLists
+        (
+            labelList& parents,
+            vectorField& centres,
+            scalarField& weights
+        ) const;
+
+        // Compute normFactor
+        virtual void computeNormFactor(const label index) const = 0;
+
+        // Compute intersections
+        virtual bool computeIntersection
+        (
+            const label newIndex,
+            const label oldIndex,
+            const label offset,
+            bool output
+        ) const = 0;
+
+        // Obtain map weighting factors
+        virtual void computeWeights
+        (
+            const label index,
+            const label offset,
+            const labelList& mapCandidates,
+            const labelListList& oldNeighbourList,
+            labelList& parents,
+            scalarField& weights,
+            vectorField& centres,
+            bool output = false
+        );
+
+        // Write out connectivity information to disk
+        bool write() const;
+
+        // Output an entity as a VTK file
+        void writeVTK
+        (
+            const word& name,
+            const label entity,
+            const label primitiveType = 3,
+            const bool useOldConnectivity = false
+        ) const;
+
+        // Output a list of entities as a VTK file
+        void writeVTK
+        (
+            const word& name,
+            const labelList& cList,
+            const label primitiveType = 3,
+            const bool useOldConnectivity = false
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.C
new file mode 100644
index 000000000..5b1e30ccd
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.C
@@ -0,0 +1,415 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    faceSetAlgorithm
+
+Description
+    Class for convexSetAlgorithms pertaining to faces
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceSetAlgorithm.H"
+
+#include "meshOps.H"
+#include "triFace.H"
+#include "polyMesh.H"
+#include "triIntersection.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+faceSetAlgorithm::faceSetAlgorithm
+(
+    const polyMesh& mesh,
+    const pointField& newPoints,
+    const UList<edge>& newEdges,
+    const UList<face>& newFaces,
+    const UList<cell>& newCells,
+    const UList<label>& newOwner,
+    const UList<label>& newNeighbour
+)
+:
+    convexSetAlgorithm
+    (
+        mesh,
+        newPoints,
+        newEdges,
+        newFaces,
+        newCells,
+        newOwner,
+        newNeighbour
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void faceSetAlgorithm::computeNormFactor(const label index) const
+{
+    // Clear existing fields
+    parents_.clear();
+
+    centres_.clear();
+    weights_.clear();
+
+    // Compute refNorm and normFactor
+    refNorm_ = newFaces_[index].normal(newPoints_);
+    normFactor_ = mag(refNorm_);
+
+    // Normalize for later use
+    refNorm_ /= normFactor_ + VSMALL;
+
+    // Compute a bounding box around the face
+    box_ = boundBox(newFaces_[index].points(newPoints_), false);
+
+    vector minToXb = (box_.min() - box_.midpoint());
+    vector maxToXb = (box_.max() - box_.midpoint());
+
+    // Scale it by a bit
+    box_.min() += (1.5 * minToXb);
+    box_.max() += (1.5 * maxToXb);
+}
+
+
+// Check whether the bounding box contains the entity
+bool faceSetAlgorithm::contains(const label index) const
+{
+    // Fetch old face
+    const face& checkFace = mesh_.faces()[index];
+
+    // Check if the bounding box contains any of the supplied points
+    forAll(checkFace, pointI)
+    {
+        if (box_.contains(mesh_.points()[checkFace[pointI]]))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+// Compute intersection
+bool faceSetAlgorithm::computeIntersection
+(
+    const label newIndex,
+    const label oldIndex,
+    const label offset,
+    bool output
+) const
+{
+    bool intersects = false;
+
+    const pointField& newPoints = newPoints_;
+    const pointField& oldPoints = mesh_.points();
+
+    const face& newFace = newFaces_[newIndex];
+    const face& oldFace = mesh_.faces()[oldIndex];
+
+    // Compute the normal for the old face
+    vector oldNorm = oldFace.normal(oldPoints);
+
+    // Normalize
+    oldNorm /= mag(oldNorm) + VSMALL;
+
+    if ((oldNorm & refNorm_) < 0.0)
+    {
+        // Opposite face orientation. Skip it.
+        return false;
+    }
+
+    // Check if decomposition is necessary
+    if (oldFace.size() > 3 || newFace.size() > 3)
+    {
+        // Decompose new / old faces
+        DynamicList<FixedList<point, 3> > clippingTris(15);
+        DynamicList<FixedList<point, 3> > subjectTris(15);
+
+        label ntOld = 0, ntNew = 0;
+        vector oldCentre = vector::zero, newCentre = vector::zero;
+
+        if (oldFace.size() == 3)
+        {
+            // Add a new entry
+            subjectTris.append(FixedList<point, 3>(vector::zero));
+
+            subjectTris[ntOld][0] = oldPoints[oldFace[0]];
+            subjectTris[ntOld][1] = oldPoints[oldFace[1]];
+            subjectTris[ntOld][2] = oldPoints[oldFace[2]];
+
+            ntOld++;
+        }
+        else
+        {
+            // Configure tris from oldFace
+            vector ofCentre = oldFace.centre(oldPoints);
+
+            forAll(oldFace, pI)
+            {
+                // Add a new entry
+                subjectTris.append(FixedList<point, 3>(vector::zero));
+
+                subjectTris[ntOld][0] = oldPoints[oldFace[pI]];
+                subjectTris[ntOld][1] = oldPoints[oldFace.nextLabel(pI)];
+                subjectTris[ntOld][2] = ofCentre;
+
+                ntOld++;
+            }
+        }
+
+        if (newFace.size() == 3)
+        {
+            // Add a new entry
+            clippingTris.append(FixedList<point, 3>(vector::zero));
+
+            clippingTris[ntNew][0] = newPoints[newFace[0]];
+            clippingTris[ntNew][1] = newPoints[newFace[1]];
+            clippingTris[ntNew][2] = newPoints[newFace[2]];
+
+            ntNew++;
+        }
+        else
+        {
+            // Configure tris from newFace
+            vector nfCentre = newFace.centre(newPoints);
+
+            forAll(newFace, pI)
+            {
+                // Add a new entry
+                clippingTris.append(FixedList<point, 3>(vector::zero));
+
+                clippingTris[ntNew][0] = newPoints[newFace[pI]];
+                clippingTris[ntNew][1] = newPoints[newFace.nextLabel(pI)];
+                clippingTris[ntNew][2] = nfCentre;
+
+                ntNew++;
+            }
+        }
+
+        // Accumulate area / centroid over all intersections
+        bool foundIntersect = false;
+
+        scalar totalArea = 0.0;
+        vector totalCentre = vector::zero;
+
+        // Loop through all clipping tris
+        forAll(clippingTris, i)
+        {
+            // Initialize the intersector
+            triIntersection intersector(clippingTris[i]);
+
+            // Test for intersection and evaluate
+            // against all subject tris
+            forAll(subjectTris, j)
+            {
+                intersects = intersector.evaluate(subjectTris[j]);
+
+                if (intersects)
+                {
+                    scalar area = 0.0;
+                    vector centre = vector::zero;
+
+                    // Fetch area and centre
+                    intersector.getAreaAndCentre(area, centre);
+
+                    // Accumulate area / centroid
+                    totalArea += area;
+                    totalCentre += (area * centre);
+
+                    foundIntersect = true;
+
+                    if (output)
+                    {
+                        writeVTK
+                        (
+                            "polygonIntersect_"
+                          + Foam::name(newIndex)
+                          + '_'
+                          + Foam::name(oldIndex)
+                          + '_' + Foam::name(i)
+                          + '_' + Foam::name(j),
+                            intersector.getIntersection()
+                        );
+                    }
+                }
+            }
+        }
+
+        // Size-up the internal lists
+        if (foundIntersect && !output)
+        {
+            // Normalize centre
+            totalCentre /= totalArea + VSMALL;
+
+            // Normalize and check if this is worth it
+            if (mag(totalArea/normFactor_) > SMALL)
+            {
+                // Size-up the internal lists
+                meshOps::sizeUpList((oldIndex - offset), parents_);
+                meshOps::sizeUpList(totalArea, weights_);
+                meshOps::sizeUpList(totalCentre, centres_);
+
+                intersects = true;
+            }
+            else
+            {
+                intersects = false;
+            }
+        }
+    }
+    else
+    {
+        // Configure points for clipping triangle
+        FixedList<point, 3> clippingTri(vector::zero);
+
+        // Fill in points
+        clippingTri[0] = newPoints[newFace[0]];
+        clippingTri[1] = newPoints[newFace[1]];
+        clippingTri[2] = newPoints[newFace[2]];
+
+        // Configure points for subject triangle
+        FixedList<point, 3> subjectTri(vector::zero);
+
+        // Fill in points
+        subjectTri[0] = oldPoints[oldFace[0]];
+        subjectTri[1] = oldPoints[oldFace[1]];
+        subjectTri[2] = oldPoints[oldFace[2]];
+
+        // Initialize the intersector
+        triIntersection intersector(clippingTri);
+
+        // Test for intersection and evaluate
+        intersects = intersector.evaluate(subjectTri);
+
+        if (intersects)
+        {
+            scalar area;
+            vector centre;
+
+            // Fetch area and centre
+            intersector.getAreaAndCentre(area, centre);
+
+            // Normalize and check if this is worth it
+            if (mag(area/normFactor_) > SMALL)
+            {
+                if (output)
+                {
+                    writeVTK
+                    (
+                        "triIntersectNew_"
+                      + Foam::name(newIndex),
+                        List<FixedList<point, 3> >(1, clippingTri)
+                    );
+
+                    writeVTK
+                    (
+                        "triIntersectOld_"
+                      + Foam::name(newIndex)
+                      + '_'
+                      + Foam::name(oldIndex),
+                        List<FixedList<point, 3> >(1, subjectTri)
+                    );
+
+                    writeVTK
+                    (
+                        "triIntersect_"
+                      + Foam::name(newIndex)
+                      + '_'
+                      + Foam::name(oldIndex),
+                        intersector.getIntersection()
+                    );
+                }
+
+                // Size-up the internal lists
+                meshOps::sizeUpList((oldIndex - offset), parents_);
+                meshOps::sizeUpList(area, weights_);
+                meshOps::sizeUpList(centre, centres_);
+            }
+            else
+            {
+                intersects = false;
+            }
+        }
+    }
+
+    return intersects;
+}
+
+
+//- Write out tris as a VTK
+void faceSetAlgorithm::writeVTK
+(
+    const word& name,
+    const List<FixedList<point, 3> >& triList
+) const
+{
+    // Fill up all points
+    label pI = 0;
+
+    List<face> allTris(triList.size(), face(3));
+    pointField allPoints(3 * triList.size());
+
+    forAll(triList, triI)
+    {
+        allTris[triI][0] = pI;
+        allPoints[pI++] = triList[triI][0];
+
+        allTris[triI][1] = pI;
+        allPoints[pI++] = triList[triI][1];
+
+        allTris[triI][2] = pI;
+        allPoints[pI++] = triList[triI][2];
+    }
+
+    // Write out in face-to-node addressing
+    meshOps::writeVTK
+    (
+        mesh_,
+        name,
+        identity(triList.size()),
+        2,
+        allPoints,
+        List<edge>(0),
+        allTris,
+        List<cell>(0),
+        List<label>(0)
+    );
+}
+
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.H
new file mode 100644
index 000000000..9bc64a740
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/faceSetAlgorithm.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    faceSetAlgorithm
+
+Description
+    Class for convexSetAlgorithms pertaining to faces
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    faceSetAlgorithm.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef faceSetAlgorithm_H
+#define faceSetAlgorithm_H
+
+#include "convexSetAlgorithm.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class faceSetAlgorithm Declaration
+\*---------------------------------------------------------------------------*/
+
+class faceSetAlgorithm
+:
+    public convexSetAlgorithm
+{
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        faceSetAlgorithm(const faceSetAlgorithm&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const faceSetAlgorithm&);
+
+        //- Write out tris as a VTK
+        void writeVTK
+        (
+            const word&,
+            const List<FixedList<point, 3> >&
+        ) const;
+
+public:
+
+    //- Constructor
+
+        faceSetAlgorithm
+        (
+            const polyMesh& mesh,
+            const pointField& newPoints,
+            const UList<edge>& newEdges,
+            const UList<face>& newFaces,
+            const UList<cell>& newCells,
+            const UList<label>& newOwner,
+            const UList<label>& newNeighbour
+        );
+
+    //- Destructor
+
+        virtual ~faceSetAlgorithm()
+        {}
+
+    //- Virtual member functions
+
+        // Dimensions of the algorithm
+        virtual label dimension() const
+        {
+            return 2;
+        }
+
+        // Compute normFactor
+        virtual void computeNormFactor(const label index) const;
+
+        // Check whether the bounding box contains the entity
+        virtual bool contains(const label index) const;
+
+        // Compute intersections
+        virtual bool computeIntersection
+        (
+            const label newIndex,
+            const label oldIndex,
+            const label offset,
+            bool output
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersection.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersection.H
new file mode 100644
index 000000000..07463de3f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersection.H
@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    tetIntersection
+
+Description
+    Implementation of the tetrahedron intersection algorithm given in:
+
+    D.H. Eberly, 3D Game Engine Design: A Practical Approach to Real-time
+    Computer Graphics, Morgan Kaufmann, 2001.
+
+    Geometric Tools, LLC
+    Distributed under the Boost Software License, Version 1.0.
+    http://www.boost.org/LICENSE_1_0.txt
+
+Implemented by
+    Sandeep Menon
+    University of Massachusetts Amherst
+
+SourceFiles
+    tetIntersectionI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tetIntersection_H
+#define tetIntersection_H
+
+#include "point.H"
+#include "label.H"
+#include "Tuple2.H"
+#include "FixedList.H"
+#include "DynamicList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class tetIntersection Declaration
+\*---------------------------------------------------------------------------*/
+
+class tetIntersection
+{
+    // Private data
+
+        //- Const reference to clipping tetrahedron
+        const FixedList<point, 4>& clipTet_;
+
+        //- Hessian-normal plane definition
+        typedef Tuple2<vector, scalar> hPlane;
+
+        FixedList<hPlane, 4> clipPlanes_;
+
+        //- Magnitude of clipping tetrahedron
+        scalar clipTetMag_;
+
+        //- Tetrahedra used as temporaries
+        DynamicList<FixedList<point, 4> > inside_;
+
+        //- All intersection tets
+        DynamicList<FixedList<point, 4> > allTets_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        tetIntersection(const tetIntersection&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const tetIntersection&);
+
+        //- Compute clip-planes
+        inline void computeClipPlanes();
+
+        //- Split and decompose
+        inline void splitAndDecompose
+        (
+            const label tetPlaneIndex,
+            FixedList<point, 4>& tetra,
+            DynamicList<FixedList<point, 4> >& decompTets
+        ) const;
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        inline tetIntersection(const FixedList<point, 4>& clipTet);
+
+
+    // Destructor
+
+        inline ~tetIntersection();
+
+
+    // Member Functions
+
+        //- Return magnitude of clipping tetrahedron
+        inline scalar clipTetMag() const;
+
+        //- Evaluate for intersections against input tetrahedron
+        inline bool evaluate(const FixedList<point, 4>& subjectTet);
+
+        //- Return intersections
+        inline const DynamicList<FixedList<point, 4> >& getIntersection() const;
+
+        //- Evaluate and return volume / centroid
+        inline void getVolumeAndCentre(scalar& volume, vector& centre) const;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tetIntersectionI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersectionI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersectionI.H
new file mode 100644
index 000000000..57e362574
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/tetIntersectionI.H
@@ -0,0 +1,387 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Implemented by
+    Sandeep Menon
+    University of Massachusetts Amherst
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Compute clip-planes
+inline void tetIntersection::computeClipPlanes()
+{
+    // Define edge vectors
+    vector edge10 = clipTet_[1] - clipTet_[0];
+    vector edge20 = clipTet_[2] - clipTet_[0];
+    vector edge30 = clipTet_[3] - clipTet_[0];
+    vector edge21 = clipTet_[2] - clipTet_[1];
+    vector edge31 = clipTet_[3] - clipTet_[1];
+
+    // Cross-products
+    clipPlanes_[0].first() = (edge20 ^ edge10);
+    clipPlanes_[1].first() = (edge10 ^ edge30);
+    clipPlanes_[2].first() = (edge30 ^ edge20);
+    clipPlanes_[3].first() = (edge21 ^ edge31);
+
+    // Normalize
+    clipPlanes_[0].first() /= mag(clipPlanes_[0].first()) + VSMALL;
+    clipPlanes_[1].first() /= mag(clipPlanes_[1].first()) + VSMALL;
+    clipPlanes_[2].first() /= mag(clipPlanes_[2].first()) + VSMALL;
+    clipPlanes_[3].first() /= mag(clipPlanes_[3].first()) + VSMALL;
+
+    // Compute magnitude of clipping tetrahedron
+    clipTetMag_ = (1.0 / 6.0) * (edge10 & clipPlanes_[3].first());
+
+    if (clipTetMag_ < 0.0)
+    {
+        // Reverse normal directions
+        clipPlanes_[0].first() = -clipPlanes_[0].first();
+        clipPlanes_[1].first() = -clipPlanes_[1].first();
+        clipPlanes_[2].first() = -clipPlanes_[2].first();
+        clipPlanes_[3].first() = -clipPlanes_[3].first();
+
+        // Reverse sign
+        clipTetMag_ = mag(clipTetMag_);
+    }
+
+    // Determine plane constants
+    clipPlanes_[0].second() = (clipTet_[0] & clipPlanes_[0].first());
+    clipPlanes_[1].second() = (clipTet_[1] & clipPlanes_[1].first());
+    clipPlanes_[2].second() = (clipTet_[2] & clipPlanes_[2].first());
+    clipPlanes_[3].second() = (clipTet_[3] & clipPlanes_[3].first());
+}
+
+
+// Split and decompose
+inline void tetIntersection::splitAndDecompose
+(
+    const label tetPlaneIndex,
+    FixedList<point, 4>& tetra,
+    DynamicList<FixedList<point, 4> >& decompTets
+) const
+{
+    FixedList<scalar, 4> C;
+    FixedList<vector, 4> tmpTetra;
+    FixedList<label, 4> pos, neg, zero;
+    label i = 0, nPos = 0, nNeg = 0, nZero = 0;
+
+    // Fetch reference to plane
+    const hPlane& tetPlane = clipPlanes_[tetPlaneIndex];
+
+    for (i = 0; i < 4; ++i)
+    {
+        // Compute distance to plane
+        C[i] = (tetra[i] & tetPlane.first()) - tetPlane.second();
+
+        if (C[i] > 0.0)
+        {
+            pos[nPos++] = i;
+        }
+        else
+        if (C[i] < 0.0)
+        {
+            neg[nNeg++] = i;
+        }
+        else
+        {
+            zero[nZero++] = i;
+        }
+    }
+
+    if (nNeg == 0)
+    {
+        return;
+    }
+
+    if (nPos == 0)
+    {
+        decompTets.append(tetra);
+        return;
+    }
+
+    // Tetrahedron is split by plane.  Determine how it is split and how to
+    // decompose the negative-side portion into tetrahedra (6 cases).
+    scalar w0, w1, invCDiff;
+    vector intp[4];
+
+    if (nPos == 3)
+    {
+        // +++-
+        for (i = 0; i < nPos; ++i)
+        {
+            invCDiff = (1.0 / (C[pos[i]] - C[neg[0]]));
+
+            w0 = -C[neg[0]] * invCDiff;
+            w1 = +C[pos[i]] * invCDiff;
+
+            tetra[pos[i]] = (w0 * tetra[pos[i]]) + (w1 * tetra[neg[0]]);
+        }
+
+        decompTets.append(tetra);
+    }
+    else
+    if (nPos == 2)
+    {
+        if (nNeg == 2)
+        {
+            // ++--
+            for (i = 0; i < nPos; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[i]] - C[neg[0]]));
+
+                w0 = -C[neg[0]] * invCDiff;
+                w1 = +C[pos[i]] * invCDiff;
+
+                intp[i] = (w0 * tetra[pos[i]]) + (w1 * tetra[neg[0]]);
+            }
+
+            for (i = 0; i < nNeg; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[i]] - C[neg[1]]));
+
+                w0 = -C[neg[1]] * invCDiff;
+                w1 = +C[pos[i]] * invCDiff;
+
+                intp[i+2] = (w0 * tetra[pos[i]]) + (w1 * tetra[neg[1]]);
+            }
+
+            tetra[pos[0]] = intp[2];
+            tetra[pos[1]] = intp[1];
+
+            decompTets.append(tetra);
+
+            tmpTetra[0] = tetra[neg[1]];
+            tmpTetra[1] = intp[3];
+            tmpTetra[2] = intp[2];
+            tmpTetra[3] = intp[1];
+
+            decompTets.append(tmpTetra);
+
+            tmpTetra[0] = tetra[neg[0]];
+            tmpTetra[1] = intp[0];
+            tmpTetra[2] = intp[1];
+            tmpTetra[3] = intp[2];
+
+            decompTets.append(tmpTetra);
+        }
+        else
+        {
+            // ++-0
+            for (i = 0; i < nPos; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[i]] - C[neg[0]]));
+
+                w0 = -C[neg[0]] * invCDiff;
+                w1 = +C[pos[i]] * invCDiff;
+
+                tetra[pos[i]] = (w0 * tetra[pos[i]]) + (w1 * tetra[neg[0]]);
+            }
+
+            decompTets.append(tetra);
+        }
+    }
+    else
+    if (nPos == 1)
+    {
+        if (nNeg == 3)
+        {
+            // +---
+            for (i = 0; i < nNeg; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[0]] - C[neg[i]]));
+
+                w0 = -C[neg[i]] * invCDiff;
+                w1 = +C[pos[0]] * invCDiff;
+
+                intp[i] = (w0 * tetra[pos[0]]) + (w1 * tetra[neg[i]]);
+            }
+
+            tetra[pos[0]] = intp[0];
+
+            decompTets.append(tetra);
+
+            tmpTetra[0] = intp[0];
+            tmpTetra[1] = tetra[neg[1]];
+            tmpTetra[2] = tetra[neg[2]];
+            tmpTetra[3] = intp[1];
+
+            decompTets.append(tmpTetra);
+
+            tmpTetra[0] = tetra[neg[2]];
+            tmpTetra[1] = intp[1];
+            tmpTetra[2] = intp[2];
+            tmpTetra[3] = intp[0];
+
+            decompTets.append(tmpTetra);
+        }
+        else
+        if (nNeg == 2)
+        {
+            // +--0
+            for (i = 0; i < nNeg; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[0]] - C[neg[i]]));
+
+                w0 = -C[neg[i]] * invCDiff;
+                w1 = +C[pos[0]] * invCDiff;
+
+                intp[i] = (w0 * tetra[pos[0]]) + (w1 * tetra[neg[i]]);
+            }
+
+            tetra[pos[0]] = intp[0];
+
+            decompTets.append(tetra);
+
+            tmpTetra[0] = intp[1];
+            tmpTetra[1] = tetra[zero[0]];
+            tmpTetra[2] = tetra[neg[1]];
+            tmpTetra[3] = intp[0];
+
+            decompTets.append(tmpTetra);
+        }
+        else
+        {
+            // +-00
+            invCDiff = (1.0 / (C[pos[0]] - C[neg[0]]));
+
+            w0 = -C[neg[0]] * invCDiff;
+            w1 = +C[pos[0]] * invCDiff;
+
+            tetra[pos[0]] = (w0 * tetra[pos[0]]) + (w1 * tetra[neg[0]]);
+
+            decompTets.append(tetra);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline tetIntersection::tetIntersection(const FixedList<point, 4>& clipTet)
+:
+    clipTet_(clipTet),
+    clipTetMag_(0.0),
+    inside_(10),
+    allTets_(10)
+{
+    // Pre-compute clipping planes
+    computeClipPlanes();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+inline tetIntersection::~tetIntersection()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Return magnitude of clipping tetrahedron
+inline scalar tetIntersection::clipTetMag() const
+{
+    return clipTetMag_;
+}
+
+
+// Evaluate for intersections
+inline bool tetIntersection::evaluate(const FixedList<point, 4>& subjectTet)
+{
+    // Clear lists
+    inside_.clear();
+    allTets_.clear();
+
+    // Add initial tetrahedron to list
+    allTets_.append(subjectTet);
+
+    // Clip second tetrahedron against planes of clipping tetrahedron
+    for (label i = 0; i < 4; i++)
+    {
+        forAll(allTets_, tetI)
+        {
+            splitAndDecompose(i, allTets_[tetI], inside_);
+        }
+
+        // Prep for next clipping plane
+        allTets_ = inside_;
+        inside_.clear();
+    }
+
+    return (allTets_.size() > 0);
+}
+
+
+// Return intersections
+inline const DynamicList<FixedList<point, 4> >&
+tetIntersection::getIntersection() const
+{
+    return allTets_;
+}
+
+
+//- Evaluate and return volume / centroid
+inline void tetIntersection::getVolumeAndCentre
+(
+    scalar& volume,
+    vector& centre
+) const
+{
+    volume = 0.0;
+    centre = vector::zero;
+
+    forAll(allTets_, tetI)
+    {
+        const FixedList<point, 4>& t = allTets_[tetI];
+
+        // Calculate volume (no check for orientation)
+        scalar tV =
+        (
+            Foam::mag
+            (
+                (1.0/6.0) *
+                (
+                    ((t[1] - t[0]) ^ (t[2] - t[0])) & (t[3] - t[0])
+                )
+            )
+        );
+
+        // Calculate centroid
+        vector tC = (0.25 * (t[0] + t[1] + t[2] + t[3]));
+
+        volume += tV;
+        centre += (tV * tC);
+    }
+
+    centre /= volume + VSMALL;
+}
+
+
+}
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersection.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersection.H
new file mode 100644
index 000000000..9960b93e1
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersection.H
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    triIntersection
+
+Description
+    Implementation of the triangle intersection algorithm
+
+Implemented by
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    triIntersectionI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef triIntersection_H
+#define triIntersection_H
+
+#include "point.H"
+#include "label.H"
+#include "Tuple2.H"
+#include "FixedList.H"
+#include "DynamicList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class triIntersection Declaration
+\*---------------------------------------------------------------------------*/
+
+class triIntersection
+{
+    // Private data
+
+        //- Const reference to clipping triangle
+        const FixedList<point, 3>& clipTri_;
+
+        //- Clip triangle normal
+        vector tNorm_;
+
+        //- Hessian-normal plane definition
+        typedef Tuple2<vector, scalar> hPlane;
+
+        FixedList<hPlane, 3> clipPlanes_;
+
+        //- Triangles used as temporaries
+        DynamicList<FixedList<point, 3> > inside_;
+
+        //- All intersection tris
+        DynamicList<FixedList<point, 3> > allTris_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        triIntersection(const triIntersection&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const triIntersection&);
+
+        //- Compute clip-planes
+        inline void computeClipPlanes();
+
+        //- Split and decompose
+        inline void splitAndDecompose
+        (
+            const label triPlaneIndex,
+            FixedList<point, 3>& tri,
+            DynamicList<FixedList<point, 3> >& decompTris
+        ) const;
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        inline triIntersection(const FixedList<point, 3>& clipTri);
+
+    // Destructor
+
+        inline ~triIntersection();
+
+    // Member Functions
+
+        //- Evaluate for intersections against input triangle
+        inline bool evaluate(const FixedList<point, 3>& subjectTri);
+
+        //- Return intersections
+        inline const DynamicList<FixedList<point, 3> >& getIntersection() const;
+
+        //- Evaluate and return area / centroid
+        inline void getAreaAndCentre(scalar& area, vector& centre) const;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "triIntersectionI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersectionI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersectionI.H
new file mode 100644
index 000000000..8e0645bec
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/triIntersectionI.H
@@ -0,0 +1,269 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Implemented by
+    Sandeep Menon
+    University of Massachusetts Amherst
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Compute clip-planes
+inline void triIntersection::computeClipPlanes()
+{
+    // Face normal
+    tNorm_ = (clipTri_[1] - clipTri_[0]) ^ (clipTri_[2] - clipTri_[0]);
+
+    // Normalize
+    tNorm_ /= mag(tNorm_) + VSMALL;
+
+    // Edge normals
+    clipPlanes_[0].first() = ((clipTri_[1] - clipTri_[0]) ^ tNorm_);
+    clipPlanes_[1].first() = ((clipTri_[2] - clipTri_[1]) ^ tNorm_);
+    clipPlanes_[2].first() = ((clipTri_[0] - clipTri_[2]) ^ tNorm_);
+
+    // Normalize
+    clipPlanes_[0].first() /= mag(clipPlanes_[0].first()) + VSMALL;
+    clipPlanes_[1].first() /= mag(clipPlanes_[1].first()) + VSMALL;
+    clipPlanes_[2].first() /= mag(clipPlanes_[2].first()) + VSMALL;
+
+    // Determine plane constants
+    clipPlanes_[0].second() = (clipTri_[0] & clipPlanes_[0].first());
+    clipPlanes_[1].second() = (clipTri_[1] & clipPlanes_[1].first());
+    clipPlanes_[2].second() = (clipTri_[2] & clipPlanes_[2].first());
+}
+
+
+// Split and decompose
+inline void triIntersection::splitAndDecompose
+(
+    const label triPlaneIndex,
+    FixedList<point, 3>& tri,
+    DynamicList<FixedList<point, 3> >& decompTris
+) const
+{
+    FixedList<scalar, 3> C;
+    FixedList<vector, 3> tmpTri;
+    FixedList<label, 3> pos, neg, zero;
+    label i = 0, nPos = 0, nNeg = 0, nZero = 0;
+
+    // Fetch reference to plane
+    const hPlane& triPlane = clipPlanes_[triPlaneIndex];
+
+    for (i = 0; i < 3; ++i)
+    {
+        // Compute distance to plane
+        C[i] = (tri[i] & triPlane.first()) - triPlane.second();
+
+        if (C[i] > 0.0)
+        {
+            pos[nPos++] = i;
+        }
+        else
+        if (C[i] < 0.0)
+        {
+            neg[nNeg++] = i;
+        }
+        else
+        {
+            zero[nZero++] = i;
+        }
+    }
+
+    if (nNeg == 0)
+    {
+        return;
+    }
+
+    if (nPos == 0)
+    {
+        decompTris.append(tri);
+        return;
+    }
+
+    // Triangle is split by plane.  Determine how it is split and how to
+    // decompose the negative-side portion into triangles (3 cases).
+    scalar w0, w1, invCDiff;
+    vector intp[3];
+
+    if (nPos == 2)
+    {
+        // ++-
+        for (i = 0; i < nPos; ++i)
+        {
+            invCDiff = (1.0 / (C[pos[i]] - C[neg[0]]));
+
+            w0 = -C[neg[0]] * invCDiff;
+            w1 = +C[pos[i]] * invCDiff;
+
+            tri[pos[i]] = (w0 * tri[pos[i]]) + (w1 * tri[neg[0]]);
+        }
+
+        decompTris.append(tri);
+    }
+    else
+    if (nPos == 1)
+    {
+        if (nNeg == 2)
+        {
+            // +--
+            for (i = 0; i < nNeg; ++i)
+            {
+                invCDiff = (1.0 / (C[pos[0]] - C[neg[i]]));
+
+                w0 = -C[neg[i]] * invCDiff;
+                w1 = +C[pos[0]] * invCDiff;
+
+                intp[i] = (w0 * tri[pos[0]]) + (w1 * tri[neg[i]]);
+            }
+
+            tri[pos[0]] = intp[0];
+
+            decompTris.append(tri);
+
+            tmpTri[0] = intp[0];
+            tmpTri[1] = tri[neg[1]];
+            tmpTri[2] = intp[1];
+
+            decompTris.append(tmpTri);
+        }
+        else
+        {
+            // +-0
+            invCDiff = (1.0 / (C[pos[0]] - C[neg[0]]));
+
+            w0 = -C[neg[0]] * invCDiff;
+            w1 = +C[pos[0]] * invCDiff;
+
+            tri[pos[0]] = (w0 * tri[pos[0]]) + (w1 * tri[neg[0]]);
+
+            decompTris.append(tri);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline triIntersection::triIntersection(const FixedList<point, 3>& clipTri)
+:
+    clipTri_(clipTri),
+    inside_(10),
+    allTris_(10)
+{
+    // Pre-compute clipping planes
+    computeClipPlanes();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+inline triIntersection::~triIntersection()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Evaluate for intersections
+inline bool triIntersection::evaluate(const FixedList<point, 3>& subjectTri)
+{
+    // Clear lists
+    inside_.clear();
+    allTris_.clear();
+
+    // Project subject triangle to clipping triangle plane
+    FixedList<point, 3> sTP(subjectTri);
+
+    for (label i = 0; i < 3; i++)
+    {
+        // Relative to zeroth face-point
+        sTP[i] -= clipTri_[0];
+
+        // Project to face
+        sTP[i] = clipTri_[0] + (sTP[i] - (sTP[i] & tNorm_)*tNorm_);
+    }
+
+    // Add initial triangle to list
+    allTris_.append(sTP);
+
+    // Clip second triangle against planes of clipping triangle
+    for (label i = 0; i < 3; i++)
+    {
+        forAll(allTris_, triI)
+        {
+            splitAndDecompose(i, allTris_[triI], inside_);
+        }
+
+        // Prep for next clipping plane
+        allTris_ = inside_;
+        inside_.clear();
+    }
+
+    return (allTris_.size() > 0);
+}
+
+
+// Return intersections
+inline const DynamicList<FixedList<point, 3> >&
+triIntersection::getIntersection() const
+{
+    return allTris_;
+}
+
+
+//- Evaluate and return area / centroid
+inline void triIntersection::getAreaAndCentre
+(
+    scalar& area,
+    vector& centre
+) const
+{
+    area = 0.0;
+    centre = vector::zero;
+
+    forAll(allTris_, triI)
+    {
+        const FixedList<point, 3>& t = allTris_[triI];
+
+        // Calculate area (no check for orientation)
+        scalar tA = Foam::mag(0.5 * ((t[1] - t[0]) ^ (t[2] - t[0])));
+
+        // Calculate centroid
+        vector tC = (1.0 / 3.0) * (t[0] + t[1] + t[2]);
+
+        area += tA;
+        centre += (tA * tC);
+    }
+
+    centre /= area + VSMALL;
+}
+
+
+}
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C
new file mode 100644
index 000000000..abe0e895a
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C
@@ -0,0 +1,636 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    coupleMap
+
+Description
+    Implementation of the coupleMap class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "coupleMap.H"
+#include "boolList.H"
+#include "demandDrivenData.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const char* coupleMap::names[coupleMap::INVALID + 1] =
+{
+    "BISECTION",
+    "COLLAPSE_FIRST",
+    "COLLAPSE_SECOND",
+    "COLLAPSE_MIDPOINT",
+    "REMOVE_CELL",
+    "MOVE_POINT",
+    "CONVERT_PATCH",
+    "INVALID"
+};
+
+// * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * * //
+
+const char* coupleMap::asText(const opType oType)
+{
+    return names[oType];
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+coupleMap::coupleMap
+(
+    const IOobject& io,
+    const bool twoDMesh,
+    const bool isLocal,
+    const bool isSend,
+    const label patchIndex,
+    const label masterIndex,
+    const label slaveIndex
+)
+:
+    regIOobject(io),
+    twoDMesh_(twoDMesh),
+    isLocal_(isLocal),
+    isSend_(isSend),
+    patchIndex_(patchIndex),
+    masterIndex_(masterIndex),
+    slaveIndex_(slaveIndex),
+    nEntities_(-1),
+    edgesPtr_(NULL),
+    facesPtr_(NULL),
+    faceEdgesPtr_(NULL)
+{
+    if
+    (
+        (io.readOpt() == IOobject::MUST_READ)
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        // Construct an Istream and read from disk.
+        readData(readStream(typeName));
+        close();
+    }
+}
+
+
+// Construct as copy
+coupleMap::coupleMap(const coupleMap& cm)
+:
+    regIOobject(cm, true),
+    twoDMesh_(cm.twoDMesh_),
+    isLocal_(cm.isLocal_),
+    isSend_(cm.isSend_),
+    patchIndex_(cm.patchIndex_),
+    masterIndex_(cm.masterIndex_),
+    slaveIndex_(cm.slaveIndex_),
+    nEntities_(cm.nEntities_),
+    edgesPtr_(NULL),
+    facesPtr_(NULL),
+    faceEdgesPtr_(NULL)
+{
+    if
+    (
+        (cm.readOpt() == IOobject::MUST_READ)
+     || (cm.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        // Construct an Istream and read from disk.
+        readData(readStream(typeName));
+        close();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
+
+coupleMap::~coupleMap()
+{
+    clearMaps();
+    clearBuffers();
+    clearAddressing();
+}
+
+
+// * * * * * * * * * * * * * * * Private Functions * * * * * * * * * * * * * //
+
+void coupleMap::clearAddressing() const
+{
+    deleteDemandDrivenData(edgesPtr_);
+    deleteDemandDrivenData(facesPtr_);
+    deleteDemandDrivenData(faceEdgesPtr_);
+}
+
+
+void coupleMap::makeEdges() const
+{
+    // It is an error to attempt to recalculate
+    // if the pointer is already set
+    if (edgesPtr_)
+    {
+        FatalErrorIn("void coupleMap::makeEdges() const")
+            << "Edges have already been calculated."
+            << abort(FatalError);
+    }
+
+    label nEdges = nEntities(coupleMap::EDGE);
+    const labelList& eBuffer = entityBuffer(coupleMap::EDGE);
+
+    edgesPtr_ = new edgeList(nEdges);
+
+    edgeList& edges = *edgesPtr_;
+
+    forAll(edges, edgeI)
+    {
+        edges[edgeI][0] = eBuffer[(2*edgeI)+0];
+        edges[edgeI][1] = eBuffer[(2*edgeI)+1];
+    }
+}
+
+
+void coupleMap::makeFaces() const
+{
+    // It is an error to attempt to recalculate
+    // if the pointer is already set
+    if (facesPtr_ || faceEdgesPtr_)
+    {
+        FatalErrorIn("void coupleMap::makeFaces() const")
+            << "Faces have already been calculated."
+            << abort(FatalError);
+    }
+
+    label nFaces = nEntities(coupleMap::FACE);
+
+    const labelList& fBuffer = entityBuffer(coupleMap::FACE);
+    const labelList& feBuffer = entityBuffer(coupleMap::FACE_EDGE);
+    const labelList& nfeBuffer = entityBuffer(coupleMap::NFE_BUFFER);
+
+    facesPtr_ = new faceList(nFaces);
+    faceEdgesPtr_ = new labelListList(nFaces);
+
+    faceList& faces = *facesPtr_;
+    labelListList& faceEdges = *faceEdgesPtr_;
+
+    label sumNFE = 0;
+
+    forAll(faces, faceI)
+    {
+        face& f = faces[faceI];
+        labelList& fe = faceEdges[faceI];
+
+        // Fetch the buffer value for 2D meshes
+        label nfe = twoDMesh_ ? nfeBuffer[faceI] : 3;
+
+        // Size up the lists
+        f.setSize(nfe, -1);
+        fe.setSize(nfe, -1);
+
+        for (label p = 0; p < nfe; p++)
+        {
+            f[p] = fBuffer[sumNFE + p];
+            fe[p] = feBuffer[sumNFE + p];
+        }
+
+        sumNFE += nfe;
+    }
+
+    if (sumNFE != nEntities(coupleMap::NFE_SIZE))
+    {
+        FatalErrorIn("void coupleMap::makeFaces() const")
+            << " Mismatched buffer." << nl
+            << " sumNFE: " << sumNFE << nl
+            << " NFE_SIZE: " << nEntities(coupleMap::NFE_SIZE) << nl
+            << abort(FatalError);
+    }
+}
+
+
+void coupleMap::makeFaceMap() const
+{
+    // It is an error to attempt to recalculate
+    // if the map is already calculated
+    if (faceMap_.size())
+    {
+        FatalErrorIn("void coupleMap::makeFaceMap() const")
+            << "faceMap has already been calculated."
+            << abort(FatalError);
+    }
+
+    const Map<label>& mapFaces = entityMap(coupleMap::FACE);
+
+    // Size the list
+    faceMap_.setSize(mapFaces.size(), -1);
+
+    // Fill-in entries
+    forAllConstIter(Map<label>, mapFaces, fIter)
+    {
+        faceMap_[fIter.key()] = fIter();
+    }
+}
+
+
+void coupleMap::makeCellMap() const
+{
+    // It is an error to attempt to recalculate
+    // if the map is already calculated
+    if (cellMap_.size())
+    {
+        FatalErrorIn("void coupleMap::makeCellMap() const")
+            << "cellMap has already been calculated."
+            << abort(FatalError);
+    }
+
+    const Map<label>& mapCells = entityMap(coupleMap::CELL);
+
+    // Size the list
+    cellMap_.setSize(mapCells.size(), -1);
+
+    // Fill-in entries
+    forAllConstIter(Map<label>, mapCells, cIter)
+    {
+        cellMap_[cIter.key()] = cIter();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+pointField& coupleMap::pointBuffer() const
+{
+    return pointBuffer_;
+}
+
+
+pointField& coupleMap::oldPointBuffer() const
+{
+    return oldPointBuffer_;
+}
+
+
+labelList& coupleMap::subMeshPoints() const
+{
+    return subMeshPoints_;
+}
+
+
+List<labelPair>& coupleMap::globalProcPoints() const
+{
+    return globalProcPoints_;
+}
+
+
+void coupleMap::allocateBuffers() const
+{
+    forAll(nEntities_, entityI)
+    {
+        if (nEntities_[entityI] < 0)
+        {
+            FatalErrorIn("void coupleMap::allocateBuffers() const")
+                << " Entity sizes are not valid." << nl
+                << " nEntities: " << nEntities_
+                << abort(FatalError);
+        }
+    }
+
+    // Size up point buffers
+    pointBuffer().setSize(nEntities(POINT));
+    oldPointBuffer().setSize(nEntities(POINT));
+
+    // Size up connectivity buffers
+    entityBuffer(POINT).setSize
+    (
+        nEntities(GLOBAL_POINT)
+      - nEntities(SHARED_POINT)
+    );
+
+    // Set edge buffer
+    entityBuffer(EDGE).setSize(2 * nEntities(EDGE));
+
+    // Set addressing buffers
+    entityBuffer(OWNER).setSize(nEntities(FACE));
+    entityBuffer(NEIGHBOUR).setSize(nEntities(INTERNAL_FACE));
+
+    // Size up boundary buffers
+    entityBuffer(FACE_STARTS).setSize(nEntities(NBDY));
+    entityBuffer(FACE_SIZES).setSize(nEntities(NBDY));
+    entityBuffer(EDGE_STARTS).setSize(nEntities(NBDY));
+    entityBuffer(EDGE_SIZES).setSize(nEntities(NBDY));
+    entityBuffer(PATCH_ID).setSize(nEntities(NBDY));
+
+    // nFaceEdges buffer is required only for 2D,
+    // due to a mix of triangle / quad faces
+    if (twoDMesh_)
+    {
+        entityBuffer(NFE_BUFFER).setSize(nEntities(FACE));
+    }
+
+    // Allocate for variable size face-lists
+    entityBuffer(FACE).setSize(nEntities(NFE_SIZE));
+    entityBuffer(FACE_EDGE).setSize(nEntities(NFE_SIZE));
+}
+
+
+label coupleMap::findSlave
+(
+    const label eType,
+    const label Index
+) const
+{
+    Map<label>::const_iterator it = entityMap_[eType].find(Index);
+
+    if (it == entityMap_[eType].end())
+    {
+        return -1;
+    }
+    else
+    {
+        return it();
+    }
+}
+
+
+label coupleMap::findMaster
+(
+    const label eType,
+    const label Index
+) const
+{
+    Map<label>::const_iterator it = reverseEntityMap_[eType].find(Index);
+
+    if (it == reverseEntityMap_[eType].end())
+    {
+        return -1;
+    }
+    else
+    {
+        return it();
+    }
+}
+
+
+void coupleMap::removeSlave
+(
+    const label eType,
+    const label Index
+) const
+{
+    Map<label>::iterator it = reverseEntityMap_[eType].find(Index);
+
+    if (it != reverseEntityMap_[eType].end())
+    {
+        reverseEntityMap_[eType].erase(it);
+    }
+}
+
+
+void coupleMap::removeMaster
+(
+    const label eType,
+    const label Index
+) const
+{
+    Map<label>::iterator it = entityMap_[eType].find(Index);
+
+    if (it != entityMap_[eType].end())
+    {
+        entityMap_[eType].erase(it);
+    }
+}
+
+
+void coupleMap::mapSlave
+(
+    const label eType,
+    const label master,
+    const label slave
+) const
+{
+    entityMap_[eType].set(master, slave);
+}
+
+
+void coupleMap::mapMaster
+(
+    const label eType,
+    const label slave,
+    const label master
+) const
+{
+    reverseEntityMap_[eType].set(slave, master);
+}
+
+
+void coupleMap::pushOperation
+(
+    const label index,
+    const opType oType,
+    const point& newPoint,
+    const point& oldPoint
+) const
+{
+    entityIndices_.setSize(entityIndices_.size() + 1, index);
+    entityOperations_.setSize(entityOperations_.size() + 1, oType);
+
+    if
+    (
+        oType == coupleMap::MOVE_POINT ||
+        oType == coupleMap::CONVERT_PATCH
+    )
+    {
+        moveNewPoints_.setSize(moveNewPoints_.size() + 1, newPoint);
+        moveOldPoints_.setSize(moveOldPoints_.size() + 1, oldPoint);
+    }
+}
+
+
+void coupleMap::transferMaps
+(
+    const label eType,
+    Map<label>& newEntityMap,
+    Map<label>& newReverseEntityMap
+) const
+{
+    entityMap_[eType].transfer(newEntityMap);
+    reverseEntityMap_[eType].transfer(newReverseEntityMap);
+}
+
+
+void coupleMap::clearMaps() const
+{
+    faceMap_.clear();
+    cellMap_.clear();
+
+    forAll(entityMap_, mapI)
+    {
+        entityMap_[mapI].clear();
+        reverseEntityMap_[mapI].clear();
+    }
+}
+
+
+void coupleMap::clearBuffers() const
+{
+    pointBuffer_.clear();
+    oldPointBuffer_.clear();
+
+    subMeshPoints_.clear();
+    globalProcPoints_.clear();
+
+    forAll(entityBuffer_, bufferI)
+    {
+        entityBuffer_[bufferI].clear();
+    }
+
+    entityIndices_.clear();
+    entityOperations_.clear();
+
+    moveNewPoints_.clear();
+    moveOldPoints_.clear();
+}
+
+
+label coupleMap::nInternalFaces() const
+{
+    return nEntities(INTERNAL_FACE);
+}
+
+
+const labelList& coupleMap::owner() const
+{
+    return entityBuffer(OWNER);
+}
+
+
+const labelList& coupleMap::neighbour() const
+{
+    return entityBuffer(NEIGHBOUR);
+}
+
+
+const edgeList& coupleMap::edges() const
+{
+    if (!edgesPtr_)
+    {
+        makeEdges();
+    }
+
+    return *edgesPtr_;
+}
+
+
+const faceList& coupleMap::faces() const
+{
+    if (!facesPtr_)
+    {
+        makeFaces();
+    }
+
+    return *facesPtr_;
+}
+
+
+const labelListList& coupleMap::faceEdges() const
+{
+    if (!faceEdgesPtr_)
+    {
+        makeFaces();
+    }
+
+    return *faceEdgesPtr_;
+}
+
+
+const labelList& coupleMap::faceMap() const
+{
+    if (faceMap_.empty())
+    {
+        makeFaceMap();
+    }
+
+    return faceMap_;
+}
+
+
+const labelList& coupleMap::cellMap() const
+{
+    if (cellMap_.empty())
+    {
+        makeCellMap();
+    }
+
+    return cellMap_;
+}
+
+
+bool coupleMap::readData(Istream& is)
+{
+    Map<label> tmpMap(is);
+
+    entityMap(coupleMap::POINT).transfer(tmpMap);
+
+    // Prepare the reversePointMap as well.
+    const Map<label>& pMap = entityMap(coupleMap::POINT);
+    Map<label>& rpMap = reverseEntityMap(coupleMap::POINT);
+
+    forAllConstIter(Map<label>, pMap, pIter)
+    {
+        rpMap.set(pIter(), pIter.key());
+    }
+
+    return !is.bad();
+}
+
+
+bool coupleMap::writeData(Ostream& os) const
+{
+    // Only write-out point-map information
+    // to avoid geometric checking.
+    // The rest can be constructed topologically.
+    return (os << entityMap(coupleMap::POINT)).good();;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void coupleMap::operator=(const coupleMap& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn("coupleMap::operator=(const coupleMap&)")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H
new file mode 100644
index 000000000..bdb356165
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H
@@ -0,0 +1,375 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    coupleMap
+
+Description
+    Coupled patch information with registry support.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    coupleMapI.H
+    coupleMap.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef coupleMap_H
+#define coupleMap_H
+
+#include "regIOobject.H"
+#include "labelList.H"
+#include "pointField.H"
+#include "fieldTypes.H"
+#include "edgeList.H"
+#include "faceList.H"
+#include "cellList.H"
+#include "labelPair.H"
+#include "Map.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class coupleMap Declaration
+\*---------------------------------------------------------------------------*/
+
+class coupleMap
+:
+    public regIOobject
+{
+
+public:
+
+    // Public data types
+
+        //- Enumerants for entity-types
+        enum entityType
+        {
+            // Buffers and sizes
+            POINT = 0,
+            EDGE = 1,
+            FACE = 2,
+            // Sizes only
+            CELL = 3,
+            INTERNAL_EDGE = 4,
+            INTERNAL_FACE = 5,
+            SHARED_POINT = 6,
+            GLOBAL_POINT = 7,
+            NFE_SIZE = 8,
+            NBDY = 9,
+            // Buffers only
+            OWNER = 3,
+            NEIGHBOUR = 4,
+            FACE_EDGE = 5,
+            NFE_BUFFER = 6,
+            FACE_STARTS = 7,
+            FACE_SIZES = 8,
+            EDGE_STARTS = 9,
+            EDGE_SIZES = 10,
+            PATCH_ID = 11
+        };
+
+        //- Enumerants for operations
+        enum opType
+        {
+            BISECTION = 0,
+            COLLAPSE_FIRST = 1,
+            COLLAPSE_SECOND = 2,
+            COLLAPSE_MIDPOINT = 3,
+            REMOVE_CELL = 4,
+            MOVE_POINT = 5,
+            CONVERT_PATCH = 6,
+            INVALID
+        };
+
+private:
+
+    // Private data
+
+        mutable bool twoDMesh_;
+
+        // Flags for coupled entities
+        mutable bool isLocal_;
+        mutable bool isSend_;
+
+        // Patch index for coupled entities
+        mutable label patchIndex_;
+
+        // Master / slave indices
+        mutable label masterIndex_;
+        mutable label slaveIndex_;
+
+        // Point buffers
+        mutable pointField pointBuffer_;
+        mutable pointField oldPointBuffer_;
+
+        // List of points that are required
+        // during patch sub-mesh creation
+        mutable labelList subMeshPoints_;
+        mutable List<labelPair> globalProcPoints_;
+
+        // Entity sizes (as specified by the entityType enumerant)
+        mutable FixedList<label,10> nEntities_;
+
+        // Maps for entities
+        mutable FixedList<Map<label>,4> entityMap_;
+        mutable FixedList<Map<label>,4> reverseEntityMap_;
+
+        // Entity Buffers (as specified by the entityType enumerant)
+        mutable FixedList<labelList,12> entityBuffer_;
+
+        // List of entity indices with topological operations
+        mutable labelList entityIndices_;
+
+        // List of operations performed on entities
+        mutable List<opType> entityOperations_;
+
+        // List of point-locations to move points to
+        mutable pointField moveNewPoints_;
+        mutable pointField moveOldPoints_;
+
+        // Addressing for field mapping
+        mutable labelList faceMap_;
+        mutable labelList cellMap_;
+
+        //- Demand-driven connectivity data.
+        mutable edgeList* edgesPtr_;
+        mutable faceList* facesPtr_;
+        mutable labelListList* faceEdgesPtr_;
+
+        void makeEdges() const;
+        void makeFaces() const;
+
+        void makeFaceMap() const;
+        void makeCellMap() const;
+
+        void clearAddressing() const;
+
+        //- Disallow default bitwise assignment
+        void operator=(const coupleMap&);
+
+public:
+
+    // Static data members
+
+        //- The set of names corresponding to the operationType enumeration
+        //  Includes an extra entry for "invalid".
+        static const char* names[INVALID + 1];
+
+        //- Runtime type information
+        TypeName("coupleMap");
+
+    // Static Member Functions
+
+        //- Return a text representation of an opType
+        static const char* asText(const opType);
+
+    // Constructors
+
+        //- Construct from components
+        coupleMap
+        (
+            const IOobject& io,
+            const bool twoDMesh,
+            const bool isLocal,
+            const bool isSend,
+            const label patchIndex,
+            const label masterIndex,
+            const label slaveIndex
+        );
+
+        //- Construct as copy
+        coupleMap(const coupleMap&);
+
+    // Destructor
+
+        virtual ~coupleMap();
+
+    //- Interpolation functions
+
+        //- Interpolate point field
+        template<class Type>
+        tmp<Field<Type> > pointInterpolate
+        (
+            const Map<label>& mPointMap,
+            const Map<label>& sPointMap,
+            const Field<Type>& pf,
+            bool reverse = false
+        ) const;
+
+        template<class Type>
+        tmp<Field<Type> > pointInterpolate
+        (
+            const Map<label>& mPointMap,
+            const Map<label>& sPointMap,
+            const tmp<Field<Type> >& tpf,
+            bool reverse = false
+        ) const;
+
+        //- Interpolate face field
+        template<class Type>
+        tmp<Field<Type> > faceInterpolate
+        (
+            const label mStart,
+            const label sStart,
+            const Field<Type>& pf,
+            bool reverse = false
+        ) const;
+
+        template<class Type>
+        tmp<Field<Type> > faceInterpolate
+        (
+            const label mStart,
+            const label sStart,
+            const tmp<Field<Type> >& tpf,
+            bool reverse = false
+        ) const;
+
+    //- Access
+
+        inline label& patchIndex() const;
+
+        inline label masterIndex() const;
+        inline label slaveIndex() const;
+
+        inline bool isTwoDMesh() const;
+        inline bool isLocal() const;
+        inline bool isProcessor() const;
+        inline bool isSend() const;
+        inline bool isRecv() const;
+
+        pointField& pointBuffer() const;
+        pointField& oldPointBuffer() const;
+
+        labelList& subMeshPoints() const;
+        List<labelPair>& globalProcPoints() const;
+
+        void allocateBuffers() const;
+
+        label findSlave
+        (
+            const label eType,
+            const label Index
+        ) const;
+
+        label findMaster
+        (
+            const label eType,
+            const label Index
+        ) const;
+
+        void removeSlave
+        (
+            const label eType,
+            const label Index
+        ) const;
+
+        void removeMaster
+        (
+            const label eType,
+            const label Index
+        ) const;
+
+        void mapSlave
+        (
+            const label eType,
+            const label master,
+            const label slave
+        ) const;
+
+        void mapMaster
+        (
+            const label eType,
+            const label slave,
+            const label master
+        ) const;
+
+        inline FixedList<label,10>& nEntities() const;
+        inline label& nEntities(const label eType) const;
+
+        inline Map<label>& entityMap(const label eType) const;
+        inline Map<label>& reverseEntityMap(const label eType) const;
+
+        inline FixedList<labelList,12>& entityBuffer() const;
+        inline labelList& entityBuffer(const label eType) const;
+
+        inline labelList& entityIndices() const;
+        inline List<opType>& entityOperations() const;
+
+        inline pointField& moveNewPoints() const;
+        inline pointField& moveOldPoints() const;
+
+        void pushOperation
+        (
+            const label index,
+            const opType oType,
+            const point& newPoint = vector::zero,
+            const point& oldPoint = vector::zero
+        ) const;
+
+        //- Demand-driven data
+        label nInternalFaces() const;
+        const labelList& owner() const;
+        const labelList& neighbour() const;
+        const edgeList& edges() const;
+        const faceList& faces() const;
+        const labelListList& faceEdges() const;
+
+        const labelList& faceMap() const;
+        const labelList& cellMap() const;
+
+        void transferMaps
+        (
+            const label eType,
+            Map<label>& newEntityMap,
+            Map<label>& newReverseEntityMap
+        ) const;
+
+        void clearMaps() const;
+
+        void clearBuffers() const;
+
+        bool readData(Istream&);
+
+        bool writeData(Ostream&) const;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#include "coupleMapI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H
new file mode 100644
index 000000000..a71f6ff6c
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H
@@ -0,0 +1,288 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//- Interpolate point field
+template<class Type>
+tmp<Field<Type> >
+coupleMap::pointInterpolate
+(
+    const Map<label>& mPointMap,
+    const Map<label>& sPointMap,
+    const Field<Type>& pf,
+    bool reverse
+) const
+{
+    const Map<label>& pointMap = entityMap(coupleMap::POINT);
+
+    if (pf.size() != pointMap.size())
+    {
+        FatalErrorIn
+        (
+            "coupleMap::pointInterpolate"
+            "(const Field<Type> pf)"
+        )   << "given field does not correspond to patch. Patch size: "
+            << pointMap.size() << " field size: " << pf.size()
+            << abort(FatalError);
+    }
+
+    tmp<Field<Type> > tresult
+    (
+        new Field<Type>
+        (
+            pointMap.size(),
+            pTraits<Type>::zero
+        )
+    );
+
+    Field<Type>& result = tresult();
+
+    if (reverse)
+    {
+        forAllConstIter(Map<label>, pointMap, pIter)
+        {
+            result[mPointMap[pIter.key()]] = pf[sPointMap[pIter()]];
+        }
+    }
+    else
+    {
+        forAllConstIter(Map<label>, pointMap, pIter)
+        {
+            result[sPointMap[pIter()]] = pf[mPointMap[pIter.key()]];
+        }
+    }
+
+    return tresult;
+}
+
+
+template<class Type>
+tmp<Field<Type> >
+coupleMap::pointInterpolate
+(
+    const Map<label>& mPointMap,
+    const Map<label>& sPointMap,
+    const tmp<Field<Type> >& tpf,
+    bool reverse
+) const
+{
+    tmp<Field<Type> > tint =
+    (
+        pointInterpolate<Type>(mPointMap, sPointMap, tpf(), reverse)
+    );
+    tpf.clear();
+    return tint;
+}
+
+
+//- Interpolate point field
+template<class Type>
+tmp<Field<Type> >
+coupleMap::faceInterpolate
+(
+    const label mStart,
+    const label sStart,
+    const Field<Type>& pf,
+    bool reverse
+) const
+{
+    const Map<label>& faceMap = entityMap(coupleMap::FACE);
+
+    if (pf.size() != faceMap.size())
+    {
+        FatalErrorIn
+        (
+            "coupleMap::faceInterpolate"
+            "(const Field<Type> pf)"
+        )   << "given field does not correspond to patch. Patch size: "
+            << faceMap.size() << " field size: " << pf.size()
+            << abort(FatalError);
+    }
+
+    tmp<Field<Type> > tresult
+    (
+        new Field<Type>
+        (
+            faceMap.size(),
+            pTraits<Type>::zero
+        )
+    );
+
+    Field<Type>& result = tresult();
+
+    if (reverse)
+    {
+        forAllConstIter(Map<label>, faceMap, fIter)
+        {
+            result[fIter.key() - mStart] = pf[fIter() - sStart];
+        }
+    }
+    else
+    {
+        forAllConstIter(Map<label>, faceMap, fIter)
+        {
+            result[fIter() - sStart] = pf[fIter.key() - mStart];
+        }
+    }
+
+    return tresult;
+}
+
+
+template<class Type>
+tmp<Field<Type> >
+coupleMap::faceInterpolate
+(
+    const label mStart,
+    const label sStart,
+    const tmp<Field<Type> >& tpf,
+    bool reverse
+) const
+{
+    tmp<Field<Type> > tint =
+    (
+        faceInterpolate<Type>(mStart, sStart, tpf(), reverse)
+    );
+    tpf.clear();
+    return tint;
+}
+
+
+inline label& coupleMap::patchIndex() const
+{
+    return patchIndex_;
+}
+
+
+inline label coupleMap::masterIndex() const
+{
+    return masterIndex_;
+}
+
+
+inline label coupleMap::slaveIndex() const
+{
+    return slaveIndex_;
+}
+
+
+inline bool coupleMap::isTwoDMesh() const
+{
+    return twoDMesh_;
+}
+
+
+inline bool coupleMap::isLocal() const
+{
+    return isLocal_;
+}
+
+
+inline bool coupleMap::isProcessor() const
+{
+    return !isLocal_;
+}
+
+
+inline bool coupleMap::isSend() const
+{
+    return isSend_;
+}
+
+
+inline bool coupleMap::isRecv() const
+{
+    return !isSend_;
+}
+
+
+inline FixedList<label,10>& coupleMap::nEntities() const
+{
+    return nEntities_;
+}
+
+
+inline label& coupleMap::nEntities(const label eType) const
+{
+    return nEntities_[eType];
+}
+
+
+inline Map<label>& coupleMap::entityMap(const label eType) const
+{
+    return entityMap_[eType];
+}
+
+
+inline Map<label>& coupleMap::reverseEntityMap(const label eType) const
+{
+    return reverseEntityMap_[eType];
+}
+
+
+inline FixedList<labelList,12>& coupleMap::entityBuffer() const
+{
+    return entityBuffer_;
+}
+
+
+inline labelList& coupleMap::entityBuffer(const label eType) const
+{
+    return entityBuffer_[eType];
+}
+
+
+inline labelList& coupleMap::entityIndices() const
+{
+    return entityIndices_;
+}
+
+
+inline List<coupleMap::opType>& coupleMap::entityOperations() const
+{
+    return entityOperations_;
+}
+
+
+inline pointField& coupleMap::moveNewPoints() const
+{
+    return moveNewPoints_;
+}
+
+
+inline pointField& coupleMap::moveOldPoints() const
+{
+    return moveOldPoints_;
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C
new file mode 100644
index 000000000..82afb1396
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C
@@ -0,0 +1,648 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "Time.H"
+#include "coupledInfo.H"
+#include "dynamicTopoFvMesh.H"
+#include "emptyFvPatchFields.H"
+#include "emptyFvsPatchFields.H"
+#include "fixedValueFvPatchFields.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Constructor for coupledInfo
+coupledInfo::coupledInfo
+(
+    const dynamicTopoFvMesh& mesh,
+    const coupleMap& cMap,
+    const label mfzIndex,
+    const label sfzIndex
+)
+:
+    mesh_(mesh),
+    builtMaps_(false),
+    map_(cMap),
+    masterFaceZone_(mfzIndex),
+    slaveFaceZone_(sfzIndex)
+{}
+
+
+coupledInfo::coupledInfo
+(
+    const dynamicTopoFvMesh& mesh,
+    const bool isTwoDMesh,
+    const bool isLocal,
+    const bool isSend,
+    const label patchIndex,
+    const label mPatch,
+    const label sPatch,
+    const label mfzIndex,
+    const label sfzIndex
+)
+:
+    mesh_(mesh),
+    builtMaps_(false),
+    map_
+    (
+        IOobject
+        (
+            "coupleMap_"
+          + Foam::name(mPatch)
+          + "_To_"
+          + Foam::name(sPatch)
+          + word(isLocal ? "_Local" : "_Proc")
+          + word(isSend ? "_Send" : "_Recv"),
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            true
+        ),
+        isTwoDMesh,
+        isLocal,
+        isSend,
+        patchIndex,
+        mPatch,
+        sPatch
+    ),
+    masterFaceZone_(mfzIndex),
+    slaveFaceZone_(sfzIndex)
+{}
+
+
+//- Construct given addressing
+coupledInfo::subMeshMapper::subMeshMapper
+(
+    const coupledInfo& cInfo,
+    const label patchI
+)
+:
+    sizeBeforeMapping_(cInfo.baseMesh().boundary()[patchI].size()),
+    directAddressing_
+    (
+        SubList<label>
+        (
+            cInfo.map().faceMap(),
+            cInfo.subMesh().boundary()[patchI].size(),
+            cInfo.subMesh().boundary()[patchI].patch().start()
+        )
+    )
+{
+    // Offset indices
+    label pStart = cInfo.baseMesh().boundary()[patchI].patch().start();
+
+    forAll(directAddressing_, faceI)
+    {
+        directAddressing_[faceI] -= pStart;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const dynamicTopoFvMesh& coupledInfo::baseMesh() const
+{
+    return mesh_;
+}
+
+
+void coupledInfo::setMesh
+(
+    label index,
+    dynamicTopoFvMesh* mesh
+)
+{
+    subMesh_.set(mesh);
+}
+
+
+dynamicTopoFvMesh& coupledInfo::subMesh()
+{
+    if (!subMesh_.valid())
+    {
+        FatalErrorIn("dynamicTopoFvMesh& coupledInfo::subMesh()")
+            << " Sub-mesh pointer has not been set."
+            << abort(FatalError);
+    }
+
+    return subMesh_();
+}
+
+
+const dynamicTopoFvMesh& coupledInfo::subMesh() const
+{
+    if (!subMesh_.valid())
+    {
+        FatalErrorIn("const dynamicTopoFvMesh& coupledInfo::subMesh() const")
+            << " Sub-mesh pointer has not been set."
+            << abort(FatalError);
+    }
+
+    return subMesh_();
+}
+
+
+bool coupledInfo::builtMaps() const
+{
+    return builtMaps_;
+}
+
+
+void coupledInfo::setBuiltMaps()
+{
+    builtMaps_ = true;
+}
+
+
+coupleMap& coupledInfo::map()
+{
+    return map_;
+}
+
+
+const coupleMap& coupledInfo::map() const
+{
+    return map_;
+}
+
+
+label coupledInfo::masterFaceZone() const
+{
+    return masterFaceZone_;
+}
+
+
+label coupledInfo::slaveFaceZone() const
+{
+    return slaveFaceZone_;
+}
+
+
+// Set subMesh centres
+void coupledInfo::setCentres(PtrList<volVectorField>& centres) const
+{
+    // Fetch reference to subMesh
+    const dynamicTopoFvMesh& mesh = subMesh();
+
+    // Set size
+    centres.setSize(1);
+
+    vectorField Cv(mesh.cellCentres());
+    vectorField Cf(mesh.faceCentres());
+
+    // Create and map the patch field values
+    label nPatches = mesh.boundary().size();
+
+    // Create field parts
+    PtrList<fvPatchField<vector> > volCentrePatches(nPatches);
+
+    // Over-ride and set all patches to fixedValue
+    for (label patchI = 0; patchI < nPatches; patchI++)
+    {
+        volCentrePatches.set
+        (
+            patchI,
+            new fixedValueFvPatchField<vector>
+            (
+                mesh.boundary()[patchI],
+                DimensionedField<vector, volMesh>::null()
+            )
+        );
+
+        // Slice field to patch (forced assignment)
+        volCentrePatches[patchI] ==
+        (
+            mesh.boundaryMesh()[patchI].patchSlice(Cf)
+        );
+    }
+
+    // Set the cell-centres pointer.
+    centres.set
+    (
+        0,
+        new volVectorField
+        (
+            IOobject
+            (
+                "cellCentres",
+                mesh.time().timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            mesh,
+            dimLength,
+            SubField<vector>(Cv, mesh.nCells()),
+            volCentrePatches
+        )
+    );
+}
+
+
+// Subset volume field
+template <class Type>
+tmp<GeometricField<Type, fvPatchField, volMesh> >
+coupledInfo::subSetVolField
+(
+    const GeometricField<Type, fvPatchField, volMesh>& fld
+) const
+{
+    // Create and map the internal-field values
+    Field<Type> internalField
+    (
+        fld.internalField(),
+        map().cellMap()
+    );
+
+    // Create and map the patch field values
+    label nPatches = subMesh().boundary().size();
+    PtrList<fvPatchField<Type> > patchFields(nPatches);
+
+    forAll(patchFields, patchI)
+    {
+        if (patchI == (nPatches - 1))
+        {
+            // Artificially set last patch
+            patchFields.set
+            (
+                patchI,
+                new emptyFvPatchField<Type>
+                (
+                    subMesh().boundary()[patchI],
+                    DimensionedField<Type, volMesh>::null()
+                )
+            );
+        }
+        else
+        {
+            patchFields.set
+            (
+                patchI,
+                fvPatchField<Type>::New
+                (
+                    fld.boundaryField()[patchI],
+                    subMesh().boundary()[patchI],
+                    DimensionedField<Type, volMesh>::null(),
+                    subMeshMapper(*this, patchI)
+                )
+            );
+        }
+    }
+
+    // Create new field from pieces
+    tmp<GeometricField<Type, fvPatchField, volMesh> > subFld
+    (
+        new GeometricField<Type, fvPatchField, volMesh>
+        (
+            IOobject
+            (
+                "subField_" + fld.name(),
+                subMesh().time().timeName(),
+                subMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            subMesh(),
+            fld.dimensions(),
+            internalField,
+            patchFields
+        )
+    );
+
+    return subFld;
+}
+
+
+// Subset surface field
+template <class Type>
+tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
+coupledInfo::subSetSurfaceField
+(
+    const GeometricField<Type, fvsPatchField, surfaceMesh>& fld
+) const
+{
+    // Create and map the internal-field values
+    Field<Type> internalField
+    (
+        fld.internalField(),
+        SubList<label>
+        (
+            map().faceMap(),
+            subMesh().nInternalFaces()
+        )
+    );
+
+    // Create and map the patch field values
+    label nPatches = subMesh().boundary().size();
+    PtrList<fvsPatchField<Type> > patchFields(nPatches);
+
+    forAll(patchFields, patchI)
+    {
+        if (patchI == (nPatches - 1))
+        {
+            // Artificially set last patch
+            patchFields.set
+            (
+                patchI,
+                new emptyFvsPatchField<Type>
+                (
+                    subMesh().boundary()[patchI],
+                    DimensionedField<Type, surfaceMesh>::null()
+                )
+            );
+        }
+        else
+        {
+            patchFields.set
+            (
+                patchI,
+                fvsPatchField<Type>::New
+                (
+                    fld.boundaryField()[patchI],
+                    subMesh().boundary()[patchI],
+                    DimensionedField<Type, surfaceMesh>::null(),
+                    subMeshMapper(*this, patchI)
+                )
+            );
+        }
+    }
+
+    // Create new field from pieces
+    tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > subFld
+    (
+        new GeometricField<Type, fvsPatchField, surfaceMesh>
+        (
+            IOobject
+            (
+                "subField_" + fld.name(),
+                subMesh().time().timeName(),
+                subMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            subMesh(),
+            fld.dimensions(),
+            internalField,
+            patchFields
+        )
+    );
+
+    return subFld;
+}
+
+
+template <class Type>
+void coupledInfo::mapVolField
+(
+    const wordList& fieldNames,
+    const word& fieldType,
+    OSstream& strStream
+) const
+{
+    strStream
+        << fieldType << token::NL
+        << token::BEGIN_BLOCK << token::NL;
+
+    forAll(fieldNames, i)
+    {
+        const GeometricField<Type, fvPatchField, volMesh>& fld =
+        (
+            mesh_.lookupObject
+            <
+                GeometricField<Type, fvPatchField, volMesh>
+            >(fieldNames[i])
+        );
+
+        tmp<GeometricField<Type, fvPatchField, volMesh> > tsubFld =
+        (
+            subSetVolField(fld)
+        );
+
+        // Send field through stream
+        strStream
+            << fieldNames[i]
+            << token::NL << token::BEGIN_BLOCK
+            << tsubFld
+            << token::NL << token::END_BLOCK
+            << token::NL;
+    }
+
+    strStream
+        << token::END_BLOCK << token::NL;
+}
+
+
+template <class Type>
+void coupledInfo::mapSurfaceField
+(
+    const wordList& fieldNames,
+    const word& fieldType,
+    OSstream& strStream
+) const
+{
+    strStream
+        << fieldType << token::NL
+        << token::BEGIN_BLOCK << token::NL;
+
+    forAll(fieldNames, i)
+    {
+        const GeometricField<Type, fvsPatchField, surfaceMesh>& fld =
+        (
+            mesh_.lookupObject
+            <
+                GeometricField<Type, fvsPatchField, surfaceMesh>
+            >(fieldNames[i])
+        );
+
+        tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tsubFld =
+        (
+            subSetSurfaceField(fld)
+        );
+
+        // Send field through stream
+        strStream
+            << fieldNames[i]
+            << token::NL << token::BEGIN_BLOCK
+            << tsubFld
+            << token::NL << token::END_BLOCK
+            << token::NL;
+    }
+
+    strStream
+        << token::END_BLOCK << token::NL;
+}
+
+
+// Set volume field pointer from input dictionary
+template <class GeomField>
+void coupledInfo::setField
+(
+    const wordList& fieldNames,
+    const dictionary& fieldDicts,
+    PtrList<GeomField>& fields
+) const
+{
+    // Size up the pointer list
+    fields.setSize(fieldNames.size());
+
+    forAll(fieldNames, i)
+    {
+        fields.set
+        (
+            i,
+            new GeomField
+            (
+                IOobject
+                (
+                    fieldNames[i],
+                    subMesh().time().timeName(),
+                    subMesh(),
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                subMesh(),
+                fieldDicts.subDict(fieldNames[i])
+            )
+        );
+    }
+}
+
+
+template <class GeomField>
+void coupledInfo::resizeMap
+(
+    const label srcIndex,
+    const subMeshMapper& internalMapper,
+    const List<labelList>& internalReverseMaps,
+    const PtrList<subMeshMapper>& boundaryMapper,
+    const List<labelListList>& boundaryReverseMaps,
+    const List<PtrList<GeomField> >& srcFields,
+    GeomField& field
+)
+{
+    // autoMap the internal field
+    field.internalField().autoMap(internalMapper);
+
+    // Reverse map for additional cells
+    forAll(srcFields, pI)
+    {
+        // Fetch field for this processor
+        const GeomField& srcField = srcFields[pI][srcIndex];
+
+        field.internalField().rmap
+        (
+            srcField.internalField(),
+            internalReverseMaps[pI]
+        );
+    }
+
+    // Map physical boundary-fields
+    forAll(boundaryMapper, patchI)
+    {
+        // autoMap the patchField
+        field.boundaryField()[patchI].autoMap(boundaryMapper[patchI]);
+
+        // Reverse map for additional patch faces
+        forAll(srcFields, pI)
+        {
+            // Fetch field for this processor
+            const GeomField& srcField = srcFields[pI][srcIndex];
+
+            field.boundaryField()[patchI].rmap
+            (
+                srcField.boundaryField()[patchI],
+                boundaryReverseMaps[pI][patchI]
+            );
+        }
+    }
+}
+
+
+// Resize all fields in registry
+template <class GeomField>
+void coupledInfo::resizeMap
+(
+    const wordList& names,
+    const objectRegistry& mesh,
+    const subMeshMapper& internalMapper,
+    const List<labelList>& internalReverseMaps,
+    const PtrList<subMeshMapper>& boundaryMapper,
+    const List<labelListList>& boundaryReverseMaps,
+    const List<PtrList<GeomField> >& srcFields
+)
+{
+    forAll(names, indexI)
+    {
+        // Fetch field from registry
+        GeomField& field =
+        (
+            const_cast<GeomField&>
+            (
+                mesh.lookupObject<GeomField>(names[indexI])
+            )
+        );
+
+        // Map the field
+        coupledInfo::resizeMap
+        (
+            indexI,
+            internalMapper,
+            internalReverseMaps,
+            boundaryMapper,
+            boundaryReverseMaps,
+            srcFields,
+            field
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void coupledInfo::operator=(const coupledInfo& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "void coupledInfo::operator=(const Foam::coupledInfo&)"
+        )
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H
new file mode 100644
index 000000000..ec65925a0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H
@@ -0,0 +1,282 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    coupledInfo
+
+Description
+    An interface class that provides patch coupling functionality
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    coupledInfo.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef coupledInfo_H
+#define coupledInfo_H
+
+#include "autoPtr.H"
+#include "coupleMap.H"
+#include "volFieldsFwd.H"
+#include "surfaceFieldsFwd.H"
+#include "fvPatchFieldMapper.H"
+
+namespace Foam
+{
+
+// Class forward declarations
+class dynamicTopoFvMesh;
+
+/*---------------------------------------------------------------------------*\
+                         Class coupledInfo Declaration
+\*---------------------------------------------------------------------------*/
+
+class coupledInfo
+{
+    // Reference to the parent mesh
+    const dynamicTopoFvMesh& mesh_;
+
+    // Auto pointer to a subMesh
+    autoPtr<dynamicTopoFvMesh> subMesh_;
+
+    // Flag to determine whether maps have been built.
+    bool builtMaps_;
+
+    // For locally coupled patches,
+    // specify a master / slave index
+    coupleMap map_;
+
+    // Zone IDs for patches associated with faceZones
+    label masterFaceZone_;
+    label slaveFaceZone_;
+
+    //- Disallow default bitwise assignment
+    inline void operator=(const coupledInfo&);
+
+public:
+
+    // Constructor
+    inline coupledInfo
+    (
+        const dynamicTopoFvMesh& mesh,
+        const coupleMap& cMap,
+        const label mfzIndex = -1,
+        const label sfzIndex = -1
+    );
+
+    inline coupledInfo
+    (
+        const dynamicTopoFvMesh& mesh,
+        const bool isTwoDMesh,
+        const bool isLocal,
+        const bool isSend,
+        const label patchIndex,
+        const label mPatch,
+        const label sPatch,
+        const label mfzIndex = -1,
+        const label sfzIndex = -1
+    );
+
+    //- Access
+
+        // Return a const reference to the parent mesh
+        inline const dynamicTopoFvMesh& baseMesh() const;
+
+        // Set a new subMesh
+        inline void setMesh(label index, dynamicTopoFvMesh* mesh);
+
+        // Return a reference to the subMesh
+        inline dynamicTopoFvMesh& subMesh();
+
+        // Return a const reference to the subMesh
+        inline const dynamicTopoFvMesh& subMesh() const;
+
+        // Have maps been built?
+        inline bool builtMaps() const;
+
+        // Change the flag
+        inline void setBuiltMaps();
+
+        // Return a reference to the coupleMap
+        inline coupleMap& map();
+
+        // Return a const reference to the coupleMap
+        inline const coupleMap& map() const;
+
+        // Return the master / slave face zone IDs
+        inline label masterFaceZone() const;
+        inline label slaveFaceZone() const;
+
+    //- Interpolation
+
+        //- Generic subMesh mapper
+        class subMeshMapper
+        :
+            public fvPatchFieldMapper
+        {
+            label sizeBeforeMapping_;
+
+            labelField directAddressing_;
+
+        public:
+
+            // Constructors
+
+                //- Construct from components
+                inline subMeshMapper
+                (
+                    const label sbm,
+                    const labelList& da
+                )
+                :
+                    sizeBeforeMapping_(sbm),
+                    directAddressing_(da)
+                {}
+
+                //- Construct given addressing
+                inline subMeshMapper
+                (
+                    const coupledInfo& cInfo,
+                    const label patchI
+                );
+
+            // Destructor
+
+                virtual ~subMeshMapper()
+                {}
+
+            // Member Functions
+
+                label size() const
+                {
+                    return directAddressing_.size();
+                }
+
+                label sizeBeforeMapping() const
+                {
+                    return directAddressing_.size();
+                }
+
+                bool direct() const
+                {
+                    return true;
+                }
+
+                const unallocLabelList& directAddressing() const
+                {
+                    return directAddressing_;
+                }
+        };
+
+        // Set subMesh centres
+        inline void setCentres(PtrList<volVectorField>& centres) const;
+
+        // Subset volume field
+        template <class Type>
+        tmp<GeometricField<Type, fvPatchField, volMesh> >
+        subSetVolField
+        (
+            const GeometricField<Type, fvPatchField, volMesh>& field
+        ) const;
+
+        // Subset surface field
+        template <class Type>
+        tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
+        subSetSurfaceField
+        (
+            const GeometricField<Type, fvsPatchField, surfaceMesh>& field
+        ) const;
+
+        // Subset the volume fields from registry to output stream
+        template <class Type>
+        void mapVolField
+        (
+            const wordList& fieldNames,
+            const word& fieldType,
+            OSstream& strStream
+        ) const;
+
+        // Subset the surface field from registry to output stream
+        template <class Type>
+        void mapSurfaceField
+        (
+            const wordList& fieldNames,
+            const word& fieldType,
+            OSstream& strStream
+        ) const;
+
+        // Set volume field pointer from input dictionary
+        template <class GeomField>
+        void setField
+        (
+            const wordList& fieldNames,
+            const dictionary& fieldDicts,
+            PtrList<GeomField>& fields
+        ) const;
+
+        // Resize map for individual field
+        template <class GeomField>
+        static void resizeMap
+        (
+            const label srcIndex,
+            const subMeshMapper& internalMapper,
+            const List<labelList>& internalReverseMaps,
+            const PtrList<subMeshMapper>& boundaryMapper,
+            const List<labelListList>& boundaryReverseMaps,
+            const List<PtrList<GeomField> >& srcFields,
+            GeomField& field
+        );
+
+        // Resize map for all fields in registry
+        template <class GeomField>
+        static void resizeMap
+        (
+            const wordList& fieldNames,
+            const objectRegistry& mesh,
+            const subMeshMapper& internalMapper,
+            const List<labelList>& internalReverseMaps,
+            const PtrList<subMeshMapper>& boundaryMapper,
+            const List<labelListList>& boundaryReverseMaps,
+            const List<PtrList<GeomField> >& srcFields
+        );
+};
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#    include "coupledInfo.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
index a501e488b..854335fdd 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
@@ -46,6 +46,7 @@ Author
 #include "volFields.H"
 #include "MeshObject.H"
 #include "topoMapper.H"
+#include "coupledInfo.H"
 #include "mapPolyMesh.H"
 #include "MapFvFields.H"
 #include "SortableList.H"
@@ -53,6 +54,7 @@ Author
 #include "fvPatchFields.H"
 #include "fvsPatchFields.H"
 #include "lengthScaleEstimator.H"
+#include "conservativeMapFields.H"
 
 namespace Foam
 {
@@ -69,7 +71,10 @@ addToRunTimeSelectionTable(dynamicFvMesh, dynamicTopoFvMesh, IOobject);
 dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
 :
     dynamicFvMesh(io),
+    baseMesh_(*this),
+    nPatches_(boundaryMesh().size()),
     topoChangeFlag_(false),
+    isSubMesh_(false),
     dict_
     (
         IOobject
@@ -78,7 +83,8 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
             polyMesh::time().constant(),
             (*this),
             IOobject::MUST_READ,
-            IOobject::NO_WRITE
+            IOobject::NO_WRITE,
+            false
         )
     ),
     mandatory_
@@ -90,7 +96,9 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     (
         dict_.subDict("dynamicTopoFvMesh").lookup("edgeRefinement")
     ),
+    loadMotionSolver_(true),
     bandWidthReduction_(false),
+    coupledModification_(false),
     interval_(1),
     eMeshPtr_(NULL),
     mapper_(NULL),
@@ -102,16 +110,16 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     owner_(polyMesh::faceOwner()),
     neighbour_(polyMesh::faceNeighbour()),
     cells_(primitiveMesh::cells()),
-    oldPatchSizes_(boundaryMesh().size(),0),
-    patchSizes_(boundaryMesh().size(),0),
-    oldPatchStarts_(boundaryMesh().size(),-1),
-    patchStarts_(boundaryMesh().size(),-1),
-    oldEdgePatchSizes_(boundaryMesh().size(),0),
-    edgePatchSizes_(boundaryMesh().size(),0),
-    oldEdgePatchStarts_(boundaryMesh().size(),-1),
-    edgePatchStarts_(boundaryMesh().size(),-1),
-    oldPatchNMeshPoints_(boundaryMesh().size(),-1),
-    patchNMeshPoints_(boundaryMesh().size(),-1),
+    oldPatchSizes_(nPatches_, 0),
+    patchSizes_(nPatches_, 0),
+    oldPatchStarts_(nPatches_, -1),
+    patchStarts_(nPatches_, -1),
+    oldEdgePatchSizes_(nPatches_, 0),
+    edgePatchSizes_(nPatches_, 0),
+    oldEdgePatchStarts_(nPatches_, -1),
+    edgePatchStarts_(nPatches_, -1),
+    oldPatchNMeshPoints_(nPatches_, -1),
+    patchNMeshPoints_(nPatches_, -1),
     nOldPoints_(primitiveMesh::nPoints()),
     nPoints_(primitiveMesh::nPoints()),
     nOldEdges_(0),
@@ -148,10 +156,10 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     readOptionalParameters();
 
     // Initialize patch-size information
-    for (label i = 0; i < boundaryMesh().size(); i++)
+    for (label i = 0; i < nPatches_; i++)
     {
         patchNMeshPoints_[i] = boundary[i].meshPoints().size();
-        oldPatchSizes_[i] = patchSizes_[i]  = boundary[i].size();
+        oldPatchSizes_[i] = patchSizes_[i] = boundary[i].size();
         oldPatchStarts_[i] = patchStarts_[i] = boundary[i].start();
         oldPatchNMeshPoints_[i] = patchNMeshPoints_[i];
     }
@@ -180,6 +188,152 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
 }
 
 
+//- Construct from components. Used for subMeshes only.
+dynamicTopoFvMesh::dynamicTopoFvMesh
+(
+    const dynamicTopoFvMesh& mesh,
+    const IOobject& io,
+    const Xfer<pointField>& points,
+    const Xfer<pointField>& oldPoints,
+    const Xfer<edgeList>& edges,
+    const Xfer<faceList>& faces,
+    const Xfer<labelListList>& faceEdges,
+    const Xfer<labelList>& owner,
+    const Xfer<labelList>& neighbour,
+    const labelList& faceStarts,
+    const labelList& faceSizes,
+    const labelList& edgeStarts,
+    const labelList& edgeSizes,
+    const wordList& patchNames,
+    const dictionary& patchDict
+)
+:
+    dynamicFvMesh
+    (
+        io,
+        oldPoints,
+        faces,
+        owner,
+        neighbour,
+        false
+    ),
+    baseMesh_(mesh),
+    nPatches_(faceStarts.size()),
+    topoChangeFlag_(false),
+    isSubMesh_(true),
+    dict_(mesh.dict_),
+    mandatory_(mesh.mandatory_),
+    twoDMesh_(mesh.twoDMesh_),
+    edgeRefinement_(mesh.edgeRefinement_),
+    loadMotionSolver_(mesh.loadMotionSolver_),
+    bandWidthReduction_(mesh.bandWidthReduction_),
+    coupledModification_(false),
+    interval_(1),
+    eMeshPtr_(NULL),
+    mapper_(NULL),
+    motionSolver_(NULL),
+    lengthEstimator_(NULL),
+    oldPoints_(polyMesh::points()),
+    points_(points()),
+    faces_(polyMesh::faces()),
+    cells_(polyMesh::cells()),
+    edges_(edges),
+    faceEdges_(faceEdges),
+    oldPatchSizes_(faceSizes),
+    patchSizes_(faceSizes),
+    oldPatchStarts_(faceStarts),
+    patchStarts_(faceStarts),
+    oldEdgePatchSizes_(edgeSizes),
+    edgePatchSizes_(edgeSizes),
+    oldEdgePatchStarts_(edgeStarts),
+    edgePatchStarts_(edgeStarts),
+    oldPatchNMeshPoints_(faceStarts.size(), -1),
+    patchNMeshPoints_(faceStarts.size(), -1),
+    nOldPoints_(points_.size()),
+    nPoints_(points_.size()),
+    nOldEdges_(edges_.size()),
+    nEdges_(edges_.size()),
+    nOldFaces_(faces_.size()),
+    nFaces_(faces_.size()),
+    nOldCells_(cells_.size()),
+    nCells_(cells_.size()),
+    nOldInternalFaces_(faceStarts[0]),
+    nInternalFaces_(faceStarts[0]),
+    nOldInternalEdges_(edgeStarts[0]),
+    nInternalEdges_(edgeStarts[0]),
+    maxModifications_(mesh.maxModifications_),
+    statistics_(0),
+    sliverThreshold_(mesh.sliverThreshold_),
+    slicePairs_(0),
+    maxTetsPerEdge_(mesh.maxTetsPerEdge_),
+    swapDeviation_(mesh.swapDeviation_),
+    allowTableResize_(mesh.allowTableResize_),
+    tetMetric_(mesh.tetMetric_)
+{
+    // Initialize owner and neighbour
+    owner_.setSize(faces_.size(), -1);
+    neighbour_.setSize(faces_.size(), -1);
+
+    // Set owner and neighbour from polyMesh
+    const labelList& own = polyMesh::faceOwner();
+    const labelList& nei = polyMesh::faceNeighbour();
+
+    forAll(own, faceI)
+    {
+        owner_[faceI] = own[faceI];
+    }
+
+    forAll(nei, faceI)
+    {
+        neighbour_[faceI] = nei[faceI];
+    }
+
+    // Initialize the multiThreading environment.
+    // Force to single-threaded.
+    initializeThreadingEnvironment(1);
+
+    const polyBoundaryMesh& boundary = polyMesh::boundaryMesh();
+
+    // Add a boundary patches for polyMesh.
+    List<polyPatch*> patches(faceStarts.size());
+
+    forAll(patches, patchI)
+    {
+        // Set the pointer
+        patches[patchI] =
+        (
+            polyPatch::New
+            (
+                patchNames[patchI],
+                patchDict.subDict
+                (
+                    patchNames[patchI]
+                ),
+                patchI,
+                boundary
+            ).ptr()
+        );
+    }
+
+    // Add patches, but don't calculate geometry, etc
+    fvMesh::addFvPatches(patches, false);
+
+    // Set sizes for the reverse maps
+    reversePointMap_.setSize(nPoints_, -7);
+    reverseEdgeMap_.setSize(nEdges_, -7);
+    reverseFaceMap_.setSize(nFaces_, -7);
+    reverseCellMap_.setSize(nCells_, -7);
+
+    // Now build edgeFaces and pointEdges information.
+    edgeFaces_ = invertManyToMany<labelList, labelList>(nEdges_, faceEdges_);
+
+    if (!twoDMesh_)
+    {
+        pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 dynamicTopoFvMesh::~dynamicTopoFvMesh()
@@ -200,9 +354,9 @@ label dynamicTopoFvMesh::insertCell
 
     if (debug > 2)
     {
-        Info << "Inserting cell: "
-             << newCellIndex << ": "
-             << newCell << endl;
+        Pout<< "Inserting cell: "
+            << newCellIndex << ": "
+            << newCell << endl;
     }
 
     cells_.append(newCell);
@@ -232,10 +386,10 @@ void dynamicTopoFvMesh::removeCell
 {
     if (debug > 2)
     {
-        Info << "Removing cell: "
-             << cIndex << ": "
-             << cells_[cIndex]
-             << endl;
+        Pout<< "Removing cell: "
+            << cIndex << ": "
+            << cells_[cIndex]
+            << endl;
     }
 
     cells_[cIndex].clear();
@@ -259,9 +413,11 @@ void dynamicTopoFvMesh::removeCell
     }
 
     // Check if this cell was added to a zone
-    if (addedCellZones_.found(cIndex))
+    Map<label>::iterator it = addedCellZones_.find(cIndex);
+
+    if (it != addedCellZones_.end())
     {
-        addedCellZones_.erase(cIndex);
+        addedCellZones_.erase(it);
     }
 
     // Check if the cell was added in the current morph, and delete
@@ -328,21 +484,28 @@ label dynamicTopoFvMesh::insertFace
 
     if (debug > 2)
     {
-        Info << "Inserting face: "
-             << newFaceIndex << ": "
-             << newFace
-             << " Owner: " << newOwner
-             << " Neighbour: " << newNeighbour;
+        Pout<< "Inserting face: "
+            << newFaceIndex << ": "
+            << newFace
+            << " Owner: " << newOwner
+            << " Neighbour: " << newNeighbour;
 
-        Info << " Patch: ";
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
 
         if (patch == -1)
         {
-            Info << "Internal" << endl;
+            Pout<< "Internal" << endl;
+        }
+        else
+        if (patch < boundary.size())
+        {
+            Pout<< boundary[patch].name() << endl;
         }
         else
         {
-            Info << boundaryMesh()[patch].name() << endl;
+            Pout<< " New patch: " << patch << endl;
         }
     }
 
@@ -355,7 +518,7 @@ label dynamicTopoFvMesh::insertFace
         // Modify patch information for this boundary face
         patchSizes_[patch]++;
 
-        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        for (label i = (patch + 1); i < nPatches_; i++)
         {
             patchStarts_[i]++;
         }
@@ -366,7 +529,7 @@ label dynamicTopoFvMesh::insertFace
         // and subsequent patch-starts
         nInternalFaces_++;
 
-        for (label i = 0; i < boundaryMesh().size(); i++)
+        for (label i = 0; i < nPatches_; i++)
         {
             patchStarts_[i]++;
         }
@@ -377,6 +540,45 @@ label dynamicTopoFvMesh::insertFace
     {
         addedFaceZones_.insert(newFaceIndex, zoneID);
     }
+    else
+    {
+        // No zone was specified. Check if this
+        // face is added to a coupled patch associated
+        // with a faceZone.
+        forAll(patchCoupling_, patchI)
+        {
+            if (patchCoupling_(patchI))
+            {
+                if (patchI == patch)
+                {
+                    if (patchCoupling_[patchI].masterFaceZone() > -1)
+                    {
+                        addedFaceZones_.insert
+                        (
+                            newFaceIndex,
+                            patchCoupling_[patchI].masterFaceZone()
+                        );
+                    }
+
+                    break;
+                }
+
+                if (patchCoupling_[patchI].map().slaveIndex() == patch)
+                {
+                    if (patchCoupling_[patchI].slaveFaceZone() > -1)
+                    {
+                        addedFaceZones_.insert
+                        (
+                            newFaceIndex,
+                            patchCoupling_[patchI].slaveFaceZone()
+                        );
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
 
     // Increment the total face count
     nFaces_++;
@@ -391,22 +593,40 @@ void dynamicTopoFvMesh::removeFace
     const label fIndex
 )
 {
-    if (debug > 2)
-    {
-        Info << "Removed face: "
-             << fIndex << ": "
-             << faces_[fIndex] << endl;
-    }
-
     // Identify the patch for this face
     label patch = whichPatch(fIndex);
 
+    if (debug > 2)
+    {
+        Pout<< "Removing face: "
+            << fIndex << ": "
+            << faces_[fIndex];
+
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
+
+        if (patch == -1)
+        {
+            Pout<< "Internal" << endl;
+        }
+        else
+        if (patch < boundary.size())
+        {
+            Pout<< boundary[patch].name() << endl;
+        }
+        else
+        {
+            Pout<< " New patch: " << patch << endl;
+        }
+    }
+
     if (patch >= 0)
     {
         // Modify patch information for this boundary face
         patchSizes_[patch]--;
 
-        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        for (label i = (patch + 1); i < nPatches_; i++)
         {
             patchStarts_[i]--;
         }
@@ -428,12 +648,18 @@ void dynamicTopoFvMesh::removeFace
     neighbour_[fIndex] = -1;
     faceEdges_[fIndex].clear();
 
-    if (twoDMesh_)
+    // Entity won't be removed from the stack for efficiency
+    // It will be discarded on access instead.
+
+    // Update coupled face maps, if necessary.
+    forAll(patchCoupling_, patchI)
     {
-        // Remove from the stack as well
-        forAll(entityStack_, stackI)
+        if (patchCoupling_(patchI))
         {
-            stack(stackI).remove(fIndex);
+            const coupleMap& cMap = patchCoupling_[patchI].map();
+
+            cMap.removeMaster(coupleMap::FACE, fIndex);
+            cMap.removeSlave(coupleMap::FACE, fIndex);
         }
     }
 
@@ -451,15 +677,19 @@ void dynamicTopoFvMesh::removeFace
     }
 
     // Check and remove from the list of added face patches
-    if (addedFacePatches_.found(fIndex))
+    Map<label>::iterator fpit = addedFacePatches_.find(fIndex);
+
+    if (fpit != addedFacePatches_.end())
     {
-        addedFacePatches_.erase(fIndex);
+        addedFacePatches_.erase(fpit);
     }
 
     // Check if this face was added to a zone
-    if (addedFaceZones_.found(fIndex))
+    Map<label>::iterator fzit = addedFaceZones_.find(fIndex);
+
+    if (fzit != addedFaceZones_.end())
     {
-        addedFaceZones_.erase(fIndex);
+        addedFaceZones_.erase(fzit);
     }
 
     // Check if the face was added in the current morph, and delete
@@ -509,9 +739,11 @@ void dynamicTopoFvMesh::removeFace
     }
 
     // Remove from the flipFaces list, if necessary
-    if (flipFaces_.found(fIndex))
+    labelHashSet::iterator ffit = flipFaces_.find(fIndex);
+
+    if (ffit != flipFaces_.end())
     {
-        flipFaces_.erase(fIndex);
+        flipFaces_.erase(ffit);
     }
 
     // Decrement the total face-count
@@ -524,8 +756,7 @@ label dynamicTopoFvMesh::insertEdge
 (
     const label patch,
     const edge& newEdge,
-    const labelList& edgeFaces,
-    const labelList& edgePoints
+    const labelList& edgeFaces
 )
 {
     label newEdgeIndex = edges_.size();
@@ -533,47 +764,28 @@ label dynamicTopoFvMesh::insertEdge
     edges_.append(newEdge);
     edgeFaces_.append(edgeFaces);
 
-    if (!twoDMesh_)
-    {
-        edgePoints_.append(edgePoints);
-    }
-
     if (debug > 2)
     {
-        Info << "Inserting edge: "
-             << newEdgeIndex << ": "
-             << newEdge;
+        Pout<< "Inserting edge: "
+            << newEdgeIndex << ": "
+            << newEdge;
 
-        Info << " Patch: ";
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
 
         if (patch == -1)
         {
-            Info << "Internal" << endl;
+            Pout<< "Internal" << endl;
+        }
+        else
+        if (patch < boundary.size())
+        {
+            Pout<< boundary[patch].name() << endl;
         }
         else
         {
-            Info << boundaryMesh()[patch].name() << endl;
-        }
-
-        if (!twoDMesh_)
-        {
-            if (findIndex(edgePoints, -1) != -1)
-            {
-                FatalErrorIn
-                (
-                    "\n"
-                    "label dynamicTopoFvMesh::insertEdge\n"
-                    "(\n"
-                    "    const label patch,\n"
-                    "    const edge& newEdge,\n"
-                    "    const labelList& edgeFaces,\n"
-                    "    const labelList& edgePoints\n"
-                    ")"
-                )
-                    << " EdgePoints is incorrectly specified." << nl
-                    << " edgePoints: " << edgePoints << nl
-                    << abort(FatalError);
-            }
+            Pout<< " New patch: " << patch << endl;
         }
     }
 
@@ -586,7 +798,7 @@ label dynamicTopoFvMesh::insertEdge
         // Modify patch information for this boundary edge
         edgePatchSizes_[patch]++;
 
-        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        for (label i = (patch + 1); i < nPatches_; i++)
         {
             edgePatchStarts_[i]++;
         }
@@ -596,7 +808,7 @@ label dynamicTopoFvMesh::insertEdge
         // Increment the number of internal edges, and subsequent patch-starts
         nInternalEdges_++;
 
-        for (label i = 0; i < boundaryMesh().size(); i++)
+        for (label i = 0; i < nPatches_; i++)
         {
             edgePatchStarts_[i]++;
         }
@@ -622,48 +834,75 @@ void dynamicTopoFvMesh::removeEdge
     const label eIndex
 )
 {
-    if (debug > 2)
-    {
-        Info << "Removing edge: "
-             << eIndex << ": "
-             << edges_[eIndex] << endl;
-    }
-
     if (!twoDMesh_)
     {
-        // Remove the edgePoints entry
-        edgePoints_[eIndex].clear();
+        const edge& rEdge = edges_[eIndex];
 
         // Size-down the pointEdges list
-        if (pointEdges_[edges_[eIndex][0]].size())
+        if (pointEdges_[rEdge[0]].size())
         {
-            meshOps::sizeDownList(eIndex, pointEdges_[edges_[eIndex][0]]);
+            meshOps::sizeDownList(eIndex, pointEdges_[rEdge[0]]);
         }
 
-        if (pointEdges_[edges_[eIndex][1]].size())
+        if (pointEdges_[rEdge[1]].size())
         {
-            meshOps::sizeDownList(eIndex, pointEdges_[edges_[eIndex][1]]);
+            meshOps::sizeDownList(eIndex, pointEdges_[rEdge[1]]);
         }
 
-        // Remove from the stack as well
-        forAll(entityStack_, stackI)
+        // Entity won't be removed from the stack for efficiency
+        // It will be discarded on access instead.
+
+        // Update coupled edge maps, if necessary.
+        forAll(patchCoupling_, patchI)
         {
-            stack(stackI).remove(eIndex);
+            if (patchCoupling_(patchI))
+            {
+                const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                cMap.removeMaster(coupleMap::EDGE, eIndex);
+                cMap.removeSlave(coupleMap::EDGE, eIndex);
+            }
         }
     }
 
-    edges_[eIndex] = edge(-1, -1);
-    edgeFaces_[eIndex].clear();
-
     // Identify the patch for this edge
     label patch = whichEdgePatch(eIndex);
 
+    if (debug > 2)
+    {
+        Pout<< "Removing edge: "
+            << eIndex << ": "
+            << edges_[eIndex];
+
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
+
+        if (patch == -1)
+        {
+            Pout<< "Internal" << endl;
+        }
+        else
+        if (patch < boundary.size())
+        {
+            Pout<< boundary[patch].name() << endl;
+        }
+        else
+        {
+            Pout<< " New patch: " << patch << endl;
+        }
+    }
+
+    // Invalidate edge and edgeFaces
+    edges_[eIndex] = edge(-1, -1);
+    edgeFaces_[eIndex].clear();
+
     if (patch >= 0)
     {
         // Modify patch information for this boundary edge
         edgePatchSizes_[patch]--;
 
-        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        for (label i = (patch + 1); i < nPatches_; i++)
         {
             edgePatchStarts_[i]--;
         }
@@ -693,9 +932,11 @@ void dynamicTopoFvMesh::removeEdge
     }
 
     // Check and remove from the list of added edge patches
-    if (addedEdgePatches_.found(eIndex))
+    Map<label>::iterator it = addedEdgePatches_.find(eIndex);
+
+    if (it != addedEdgePatches_.end())
     {
-        addedEdgePatches_.erase(eIndex);
+        addedEdgePatches_.erase(it);
     }
 
     // Decrement the total edge-count
@@ -720,13 +961,13 @@ label dynamicTopoFvMesh::insertPoint
 
     if (debug > 2)
     {
-        Info << "Inserting new point: "
-             << newPointIndex << ": "
-             << newPoint
-             << " and old point: "
-             << oldPoint
-             << "  Mapped from: "
-             << mapPoints << endl;
+        Pout<< "Inserting new point: "
+            << newPointIndex << ": "
+            << newPoint
+            << " and old point: "
+            << oldPoint
+            << "  Mapped from: "
+            << mapPoints << endl;
     }
 
     // Make a pointsFromPoints entry
@@ -763,9 +1004,10 @@ void dynamicTopoFvMesh::removePoint
 {
     if (debug > 2)
     {
-        Info << "Removing point: "
-             << pIndex << ": "
-             << points_[pIndex] << endl;
+        Pout<< "Removing point: " << pIndex
+            << " :: new: " << points_[pIndex]
+            << " :: old: " << oldPoints_[pIndex]
+            << endl;
     }
 
     // Remove the point
@@ -790,9 +1032,35 @@ void dynamicTopoFvMesh::removePoint
     }
 
     // Check if this point was added to a zone
-    if (addedPointZones_.found(pIndex))
+    Map<label>::iterator pzit = addedPointZones_.find(pIndex);
+
+    if (pzit != addedPointZones_.end())
     {
-        addedPointZones_.erase(pIndex);
+        addedPointZones_.erase(pzit);
+    }
+
+    // Update coupled point maps, if necessary.
+    forAll(patchCoupling_, patchI)
+    {
+        if (patchCoupling_(patchI))
+        {
+            // Obtain references
+            const coupleMap & cMap = patchCoupling_[patchI].map();
+
+            Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+            Map<label>& rPointMap = cMap.reverseEntityMap(coupleMap::POINT);
+
+            Map<label>::iterator pmit = pointMap.find(pIndex);
+
+            if (pmit != pointMap.end())
+            {
+                // Erase the reverse map first
+                rPointMap.erase(pmit());
+
+                // Update pointMap
+                pointMap.erase(pmit);
+            }
+        }
     }
 
     // Check if the point was added in the current morph, and delete
@@ -811,25 +1079,27 @@ void dynamicTopoFvMesh::removePoint
 }
 
 
-// Utility method to build edgePoints for an edge [3D].
+// Utility method to build vertexHull for an edge [3D].
 // Assumes that edgeFaces information is consistent.
-void dynamicTopoFvMesh::buildEdgePoints
+void dynamicTopoFvMesh::buildVertexHull
 (
     const label eIndex,
+    labelList& vertexHull,
     const label checkIndex
-)
+) const
 {
     bool found = false;
     label faceIndex = -1, cellIndex = -1;
     label otherPoint = -1, nextPoint = -1;
+    label failMode = 0;
 
     // Obtain references
     const edge& edgeToCheck = edges_[eIndex];
     const labelList& eFaces = edgeFaces_[eIndex];
 
     // Re-size the list first
-    labelList& ePoints = edgePoints_[eIndex];
-    ePoints.setSize(eFaces.size(), -1);
+    vertexHull.clear();
+    vertexHull.setSize(eFaces.size(), -1);
 
     if (whichEdgePatch(eIndex) == -1)
     {
@@ -861,122 +1131,404 @@ void dynamicTopoFvMesh::buildEdgePoints
         }
     }
 
-    // Shuffle vertices to appear in CCW order
-    forAll(ePoints, indexI)
+    if (faceIndex == -1)
     {
-        meshOps::findIsolatedPoint
-        (
-            faces_[faceIndex],
-            edgeToCheck,
-            otherPoint,
-            nextPoint
-        );
-
-        // Add the isolated point
-        ePoints[indexI] = otherPoint;
-
-        // Figure out how this edge is oriented.
-        if (nextPoint == edgeToCheck[checkIndex])
+        // Define failure-mode
+        failMode = 1;
+    }
+    else
+    {
+        // Shuffle vertices to appear in CCW order
+        forAll(vertexHull, indexI)
         {
-            // Counter-clockwise. Pick the owner.
-            cellIndex = owner_[faceIndex];
-        }
-        else
-        if (whichPatch(faceIndex) == -1)
-        {
-            // Clockwise. Pick the neighbour.
-            cellIndex = neighbour_[faceIndex];
-        }
-        else
-        {
-            // Looks like we've hit a boundary face. Break out.
-            break;
-        }
-
-        const cell& cellToCheck = cells_[cellIndex];
-
-        found = false;
-
-        // Assuming tet-cells,
-        // Loop through edgeFaces and get the next face
-        forAll(eFaces, faceI)
-        {
-            if
+            meshOps::findIsolatedPoint
             (
-                eFaces[faceI] != faceIndex
-             && eFaces[faceI] == cellToCheck[0]
-            )
+                faces_[faceIndex],
+                edgeToCheck,
+                otherPoint,
+                nextPoint
+            );
+
+            // Add the isolated point
+            vertexHull[indexI] = otherPoint;
+
+            // Figure out how this edge is oriented.
+            if (nextPoint == edgeToCheck[checkIndex])
             {
-                faceIndex = cellToCheck[0];
-                found = true; break;
+                // Counter-clockwise. Pick the owner.
+                cellIndex = owner_[faceIndex];
+            }
+            else
+            if (whichPatch(faceIndex) == -1)
+            {
+                // Clockwise. Pick the neighbour.
+                cellIndex = neighbour_[faceIndex];
+            }
+            else
+            if (indexI != (vertexHull.size() - 1))
+            {
+                // This could be a pinched manifold edge
+                // (situation with more than two boundary faces)
+                // Pick another (properly oriented) boundary face.
+                faceIndex = -1;
+
+                forAll(eFaces, faceI)
+                {
+                    if (whichPatch(eFaces[faceI]) > -1)
+                    {
+                        meshOps::findIsolatedPoint
+                        (
+                            faces_[eFaces[faceI]],
+                            edgeToCheck,
+                            otherPoint,
+                            nextPoint
+                        );
+
+                        if
+                        (
+                            (nextPoint == edgeToCheck[checkIndex]) &&
+                            (findIndex(vertexHull, otherPoint) == -1)
+                        )
+                        {
+                            faceIndex = eFaces[faceI];
+                            break;
+                        }
+                    }
+                }
+
+                if (faceIndex == -1)
+                {
+                    failMode = 2;
+                    break;
+                }
+                else
+                {
+                    continue;
+                }
+            }
+            else
+            {
+                // Looks like we've hit the last boundary face. Break out.
+                break;
             }
 
-            if
-            (
-                eFaces[faceI] != faceIndex
-             && eFaces[faceI] == cellToCheck[1]
-            )
-            {
-                faceIndex = cellToCheck[1];
-                found = true; break;
-            }
+            const cell& cellToCheck = cells_[cellIndex];
 
-            if
-            (
-                eFaces[faceI] != faceIndex
-             && eFaces[faceI] == cellToCheck[2]
-            )
-            {
-                faceIndex = cellToCheck[2];
-                found = true; break;
-            }
-
-            if
-            (
-                eFaces[faceI] != faceIndex
-             && eFaces[faceI] == cellToCheck[3]
-            )
-            {
-                faceIndex = cellToCheck[3];
-                found = true; break;
-            }
-        }
-
-        if (!found)
-        {
-            Info << "edgeFaces: " << endl;
+            found = false;
 
+            // Assuming tet-cells,
+            // Loop through edgeFaces and get the next face
             forAll(eFaces, faceI)
             {
-                Info << " Face: " << eFaces[faceI]
-                     << ":: " << faces_[eFaces[faceI]]
-                     << " Owner: " << owner_[eFaces[faceI]]
-                     << " Neighbour: " << neighbour_[eFaces[faceI]]
-                     << endl;
+                if
+                (
+                    eFaces[faceI] != faceIndex
+                 && eFaces[faceI] == cellToCheck[0]
+                )
+                {
+                    faceIndex = cellToCheck[0];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFaces[faceI] != faceIndex
+                 && eFaces[faceI] == cellToCheck[1]
+                )
+                {
+                    faceIndex = cellToCheck[1];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFaces[faceI] != faceIndex
+                 && eFaces[faceI] == cellToCheck[2]
+                )
+                {
+                    faceIndex = cellToCheck[2];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFaces[faceI] != faceIndex
+                 && eFaces[faceI] == cellToCheck[3]
+                )
+                {
+                    faceIndex = cellToCheck[3];
+                    found = true; break;
+                }
             }
 
-            writeVTK("vRingEdgeFaces", eFaces, 2);
-            writeVTK("vRingCellToCheck", cellIndex);
+            if (!found)
+            {
+                failMode = 3;
+                break;
+            }
+        }
+    }
 
-            // Something's terribly wrong
-            FatalErrorIn
-            (
-                "\n"
-                "void dynamicTopoFvMesh::buildEdgePoints\n"
-                "(\n"
-                "    const label eIndex,\n"
-                "    const label checkIndex\n"
-                ")"
-            )
-                << " Failed to determine a vertex ring. " << nl
-                << " edgeFaces connectivity is inconsistent. " << nl
-                << " Edge: " << eIndex << ":: " << edgeToCheck << nl
-                << " edgeFaces: " << eFaces << nl
-                << " Patch: " << whichEdgePatch(eIndex) << nl
-                << " cellIndex: " << cellIndex
-                << " :: " << cellToCheck << nl
-                << " Current edgePoints: " << ePoints
-                << abort(FatalError);
+    if (debug > 2 && !failMode)
+    {
+        // Check for invalid indices
+        if (findIndex(vertexHull, -1) > -1)
+        {
+            failMode = 4;
+        }
+
+        // Check for duplicate labels
+        if (!failMode)
+        {
+            labelHashSet uniquePoints;
+
+            forAll(vertexHull, pointI)
+            {
+                bool inserted = uniquePoints.insert(vertexHull[pointI]);
+
+                if (!inserted)
+                {
+                    Pout<< " vertexHull for edge: "
+                        << eIndex << "::" << edgeToCheck
+                        << " contains identical vertex labels: "
+                        << vertexHull << endl;
+
+                    failMode = 5;
+                }
+            }
+        }
+    }
+
+    if (failMode)
+    {
+        // Prepare edgeCells
+        DynamicList<label> eCells(10);
+
+        forAll(eFaces, faceI)
+        {
+            label own = owner_[eFaces[faceI]];
+            label nei = neighbour_[eFaces[faceI]];
+
+            if (findIndex(eCells, own) == -1)
+            {
+                eCells.append(own);
+            }
+
+            if (nei > -1)
+            {
+                if (findIndex(eCells, nei) == -1)
+                {
+                    eCells.append(nei);
+                }
+            }
+        }
+
+        // Write out for post-processing
+        label eI = eIndex, epI = whichEdgePatch(eIndex);
+        word epName(epI < 0 ? "Internal" : boundaryMesh()[epI].name());
+
+        writeVTK("vRingEdge_" + Foam::name(eI), eIndex, 1, false, true);
+        writeVTK("vRingEdgeFaces_" + Foam::name(eI), eFaces, 2, false, true);
+        writeVTK("vRingEdgeCells_" + Foam::name(eI), eCells, 3, false, true);
+
+        Pout<< "edgeFaces: " << endl;
+
+        forAll(eFaces, faceI)
+        {
+            label fpI = whichPatch(eFaces[faceI]);
+            word fpName(fpI < 0 ? "Internal" : boundaryMesh()[fpI].name());
+
+            Pout<< " Face: " << eFaces[faceI]
+                << ":: " << faces_[eFaces[faceI]]
+                << " Owner: " << owner_[eFaces[faceI]]
+                << " Neighbour: " << neighbour_[eFaces[faceI]]
+                << " Patch: " << fpName
+                << endl;
+        }
+
+        FatalErrorIn
+        (
+            "\n"
+            "void dynamicTopoFvMesh::buildVertexHull\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    labelList& vertexHull,\n"
+            "    const label checkIndex\n"
+            ")\n"
+        )
+            << " Failed to determine a vertex ring. " << nl
+            << " Failure mode: " << failMode << nl
+            << " Edge: " << eIndex << ":: " << edgeToCheck << nl
+            << " edgeFaces: " << eFaces << nl
+            << " Patch: " << epName << nl
+            << " Current vertexHull: " << vertexHull
+            << abort(FatalError);
+    }
+}
+
+
+void dynamicTopoFvMesh::handleMeshSlicing()
+{
+    if (slicePairs_.empty())
+    {
+        return;
+    }
+
+    if (lengthEstimator().holdOff())
+    {
+        // Clear out data.
+        slicePairs_.clear();
+        lengthEstimator().clearBoxes();
+
+        // Hold-off mesh slicing for a few time-steps.
+        lengthEstimator().decrementHoldOff();
+
+        return;
+    }
+
+    Info<< "Slicing Mesh...";
+
+    // Loop through candidates and weed-out invalid points
+    forAll(slicePairs_, pairI)
+    {
+        const labelPair& pairToCheck = slicePairs_[pairI];
+
+        bool available = true;
+
+        if (twoDMesh_)
+        {
+            forAll(pairToCheck, indexI)
+            {
+                if (deletedFaces_.found(pairToCheck[indexI]))
+                {
+                    available = false;
+                    break;
+                }
+
+                if (pairToCheck[indexI] < nOldFaces_)
+                {
+                    if (reverseFaceMap_[pairToCheck[indexI]] == -1)
+                    {
+                        available = false;
+                        break;
+                    }
+                }
+            }
+        }
+        else
+        {
+            forAll(pairToCheck, indexI)
+            {
+                if (deletedPoints_.found(pairToCheck[indexI]))
+                {
+                    available = false;
+                    break;
+                }
+
+                if (pairToCheck[indexI] < nOldPoints_)
+                {
+                    if (reversePointMap_[pairToCheck[indexI]] == -1)
+                    {
+                        available = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (available)
+        {
+            // Slice the mesh at this point.
+            sliceMesh(pairToCheck);
+        }
+    }
+
+    Info<< "Done." << endl;
+
+    // Clear out data.
+    slicePairs_.clear();
+    lengthEstimator().clearBoxes();
+
+    // Set the sliceHoldOff value
+    lengthEstimator().setHoldOff(50);
+}
+
+
+// Handle layer addition / removal events
+void dynamicTopoFvMesh::handleLayerAdditionRemoval()
+{
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+    if (meshSubDict.found("layering") || mandatory_)
+    {
+        // Bail out if no entries are present
+        if (meshSubDict.subDict("layering").empty())
+        {
+            return;
+        }
+    }
+    else
+    {
+        // No dictionary present.
+        return;
+    }
+
+    // Fetch layering patches
+    const polyBoundaryMesh& boundary = boundaryMesh();
+    const dictionary& layeringDict = meshSubDict.subDict("layering");
+
+    wordList layeringPatches = layeringDict.toc();
+
+    forAll(layeringPatches, wordI)
+    {
+        word pName = layeringPatches[wordI];
+        label patchID = boundary.findPatchID(pName);
+
+        // If this patch has no faces, move on
+        if (boundary[patchID].empty())
+        {
+            continue;
+        }
+
+        // Use first face to determine layer thickness
+        scalar magSf = mag(boundary[patchID].faceAreas()[0]);
+        scalar Vc = cellVolumes()[boundary[patchID].faceCells()[0]];
+
+        // Define thickness
+        scalar thickness = (Vc / (magSf + VSMALL));
+
+        // Fetch min / max thickness
+        scalar minThickness =
+        (
+            readScalar(layeringDict.subDict(pName).lookup("minThickness"))
+        );
+
+        scalar maxThickness =
+        (
+            readScalar(layeringDict.subDict(pName).lookup("maxThickness"))
+        );
+
+        if (debug)
+        {
+            Pout<< " Patch: " << pName << nl
+                << " Face area: " << magSf << nl
+                << " Cell volume: " << Vc << nl
+                << " Layer thickness: " << thickness << nl
+                << " Min thickness: " << minThickness << nl
+                << " Max thickness: " << maxThickness << nl
+                << endl;
+        }
+
+        if (thickness > maxThickness)
+        {
+            // Add cell layer above patch
+            addCellLayer(patchID);
+        }
+        else
+        if (thickness < minThickness)
+        {
+            // Remove cell layer above patch
+            removeCellLayer(patchID);
         }
     }
 }
@@ -1193,7 +1745,23 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
     // Enable/disable run-time debug level
     if (meshSubDict.found("debug") || mandatory_)
     {
-        debug = readLabel(meshSubDict.lookup("debug"));
+        // Look for a processor-specific debug flag
+        if (Pstream::parRun() && meshSubDict.found("parDebugProcs"))
+        {
+            labelList procs(meshSubDict.lookup("parDebugProcs"));
+
+            forAll(procs, procI)
+            {
+                if (Pstream::myProcNo() == procs[procI])
+                {
+                    debug = readLabel(meshSubDict.lookup("debug"));
+                }
+            }
+        }
+        else
+        {
+            debug = readLabel(meshSubDict.lookup("debug"));
+        }
     }
     else
     {
@@ -1201,8 +1769,6 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
     }
 
     // Set debug option for underlying classes as well.
-    lengthScaleEstimator::debug = debug;
-
     if (debug > 2)
     {
         fvMesh::debug = true;
@@ -1230,6 +1796,12 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
         interval_ = 1;
     }
 
+    // Check if an external mesh-motion solver is used
+    if (meshSubDict.found("loadMotionSolver") || mandatory_)
+    {
+        loadMotionSolver_.readIfPresent("loadMotionSolver", meshSubDict);
+    }
+
     // Update bandwidth reduction switch
     if (meshSubDict.found("bandwidthReduction") || mandatory_)
     {
@@ -1317,6 +1889,13 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
             allowTableResize_ = false;
         }
     }
+
+    // Check for load-balancing in parallel
+    if (reRead && (meshSubDict.found("loadBalancing") || mandatory_))
+    {
+        // Execute balancing
+        executeLoadBalancing(meshSubDict.subDict("loadBalancing"));
+    }
 }
 
 
@@ -1345,12 +1924,15 @@ void dynamicTopoFvMesh::initEdges()
 
     if (!twoDMesh_)
     {
-        pointEdges_ = eMeshPtr_->pointEdges();
-        edgePoints_ = eMeshPtr_->edgePoints();
+        // Invert edges to obtain pointEdges
+        pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
     }
 
     // Clear out unwanted eMesh connectivity
     eMeshPtr_->clearOut();
+
+    // Read coupled patch information from dictionary.
+    readCoupledPatches();
 }
 
 
@@ -1382,7 +1964,7 @@ void dynamicTopoFvMesh::loadMotionSolver()
           << abort(FatalError);
     }
     else
-    if (dict_.found("solver"))
+    if (dict_.found("solver") && loadMotionSolver_)
     {
         motionSolver_ = motionSolver::New(*this);
     }
@@ -1435,6 +2017,15 @@ void dynamicTopoFvMesh::loadLengthScaleEstimator()
             false,
             mandatory_
         );
+
+        // Set coupled patch options, if available
+        if (dict_.found("coupledPatches") || mandatory_)
+        {
+            lengthEstimator().setCoupledPatches
+            (
+                dict_.subDict("coupledPatches")
+            );
+        }
     }
 }
 
@@ -1578,10 +2169,10 @@ void dynamicTopoFvMesh::swap2DEdges(void *argument)
                     )
                 );
 
-                Info << "  Swap Progress: " << percent << "% :"
-                     << "  Total: " << mesh.status(1)
-                     << "             \r"
-                     << flush;
+                Info<< "  Swap Progress: " << percent << "% :"
+                    << "  Total: " << mesh.status(1)
+                    << "             \r"
+                    << flush;
 
                 reported = true;
             }
@@ -1615,10 +2206,10 @@ void dynamicTopoFvMesh::swap2DEdges(void *argument)
 
     if (reported)
     {
-        Info << "  Swap Progress: 100% :"
-             << "  Total: " << mesh.status(1)
-             << "             \r"
-             << endl;
+        Info<< "  Swap Progress: 100% :"
+            << "  Total: " << mesh.status(1)
+            << "             \r"
+            << endl;
     }
 }
 
@@ -1647,6 +2238,9 @@ void dynamicTopoFvMesh::swap3DEdges
     PtrList<scalarListList> Q;
     PtrList<labelListList> K, triangulations;
 
+    // Hull vertices information
+    labelList hullV;
+
     // Allocate dynamic programming tables
     mesh.initTables(m, Q, K, triangulations);
 
@@ -1681,11 +2275,11 @@ void dynamicTopoFvMesh::swap3DEdges
                     )
                 );
 
-                Info << "  Swap Progress: " << percent << "% :"
-                     << "  Surface: " << mesh.status(2)
-                     << ", Total: " << mesh.status(1)
-                     << "             \r"
-                     << flush;
+                Info<< "  Swap Progress: " << percent << "% :"
+                    << "  Surface: " << mesh.status(2)
+                    << ", Total: " << mesh.status(1)
+                    << "             \r"
+                    << flush;
 
                 reported = true;
             }
@@ -1695,16 +2289,17 @@ void dynamicTopoFvMesh::swap3DEdges
         label eIndex = mesh.stack(tIndex).pop();
 
         // Compute the minimum quality of cells around this edge
-        scalar minQuality = mesh.computeMinQuality(eIndex);
+        scalar minQuality = mesh.computeMinQuality(eIndex, hullV);
 
         // Check if this edge is on a bounding curve
-        if (mesh.checkBoundingCurve(eIndex))
+        // (Override purity check for processor edges)
+        if (mesh.checkBoundingCurve(eIndex, true))
         {
             continue;
         }
 
         // Fill the dynamic programming tables
-        if (mesh.fillTables(eIndex, minQuality, m, Q, K, triangulations))
+        if (mesh.fillTables(eIndex, minQuality, m, hullV, Q, K, triangulations))
         {
             // Check if edge-swapping is required.
             if (mesh.checkQuality(eIndex, m, Q, minQuality))
@@ -1712,7 +2307,15 @@ void dynamicTopoFvMesh::swap3DEdges
                 if (thread->master())
                 {
                     // Remove this edge according to the swap sequence
-                    mesh.removeEdgeFlips(eIndex, minQuality, K, triangulations);
+                    mesh.removeEdgeFlips
+                    (
+                        eIndex,
+                        minQuality,
+                        hullV,
+                        Q,
+                        K,
+                        triangulations
+                    );
                 }
                 else
                 {
@@ -1730,11 +2333,11 @@ void dynamicTopoFvMesh::swap3DEdges
 
     if (reported)
     {
-        Info << "  Swap Progress: 100% :"
-             << "  Surface: " << mesh.status(2)
-             << ", Total: " << mesh.status(1)
-             << "             \r"
-             << endl;
+        Info<< "  Swap Progress: 100% :"
+            << "  Surface: " << mesh.status(2)
+            << ", Total: " << mesh.status(1)
+            << "             \r"
+            << endl;
     }
 }
 
@@ -1792,12 +2395,12 @@ void dynamicTopoFvMesh::edgeRefinementEngine
                     )
                 );
 
-                Info << "  Refinement Progress: " << percent << "% :"
-                     << "  Bisections: " << mesh.status(3)
-                     << ", Collapses: " << mesh.status(4)
-                     << ", Total: " << mesh.status(0)
-                     << "             \r"
-                     << flush;
+                Info<< "  Refinement Progress: " << percent << "% :"
+                    << "  Bisections: " << mesh.status(3)
+                    << ", Collapses: " << mesh.status(4)
+                    << ", Total: " << mesh.status(0)
+                    << "             \r"
+                    << flush;
 
                 reported = true;
             }
@@ -1842,12 +2445,12 @@ void dynamicTopoFvMesh::edgeRefinementEngine
 
     if (reported)
     {
-        Info << "  Refinement Progress: 100% :"
-             << "  Bisections: " << mesh.status(3)
-             << ", Collapses: " << mesh.status(4)
-             << ", Total: " << mesh.status(0)
-             << "             \r"
-             << endl;
+        Info<< "  Refinement Progress: 100% :"
+            << "  Bisections: " << mesh.status(3)
+            << ", Collapses: " << mesh.status(4)
+            << ", Total: " << mesh.status(0)
+            << "             \r"
+            << endl;
     }
 }
 
@@ -1855,6 +2458,12 @@ void dynamicTopoFvMesh::edgeRefinementEngine
 // Remove 2D sliver cells from the mesh
 void dynamicTopoFvMesh::remove2DSlivers()
 {
+    // If coupled patches exist, set the flag
+    if (patchCoupling_.size() || procIndices_.size())
+    {
+        setCoupledModification();
+    }
+
     // Sort by sliver-quality.
     labelList cIndices(thresholdSlivers_.toc());
     SortableList<scalar> values(cIndices.size());
@@ -1874,15 +2483,15 @@ void dynamicTopoFvMesh::remove2DSlivers()
     {
         if (thresholdSlivers_.size())
         {
-            Info << "Sliver list: " << endl;
+            Pout<< "Sliver list: " << endl;
 
             forAll(indices, indexI)
             {
                 label cIndex = cIndices[indices[indexI]];
 
-                Info << " Cell: " << cIndex
-                     << " Quality: " << thresholdSlivers_[cIndex]
-                     << endl;
+                Pout<< " Cell: " << cIndex
+                    << " Quality: " << thresholdSlivers_[cIndex]
+                    << endl;
             }
 
             if (debug > 1)
@@ -2034,17 +2643,17 @@ void dynamicTopoFvMesh::remove2DSlivers()
 
             // Loop through added faces, and collapse
             // the appropriate one
-            const List<FixedList<label,2> >& aF = map.addedFaceList();
+            const List<objectMap>& aF = map.addedFaceList();
 
             forAll(aF, faceI)
             {
                 if
                 (
-                    (owner_[aF[faceI][0]] == cIndex) &&
-                    (aF[faceI][0] != firstFace)
+                    (owner_[aF[faceI].index()] == cIndex) &&
+                    (aF[faceI].index() != firstFace)
                 )
                 {
-                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
                         statistics_[7]++;
                     }
@@ -2062,17 +2671,17 @@ void dynamicTopoFvMesh::remove2DSlivers()
 
             // Loop through added faces, and collapse
             // the appropriate one
-            const List<FixedList<label,2> >& aF = map.addedFaceList();
+            const List<objectMap>& aF = map.addedFaceList();
 
             forAll(aF, faceI)
             {
                 if
                 (
-                    (owner_[aF[faceI][0]] == cIndex) &&
-                    (aF[faceI][0] != secondFace)
+                    (owner_[aF[faceI].index()] == cIndex) &&
+                    (aF[faceI].index() != secondFace)
                 )
                 {
-                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
                         statistics_[7]++;
                     }
@@ -2090,17 +2699,17 @@ void dynamicTopoFvMesh::remove2DSlivers()
 
             // Loop through added faces, and collapse
             // the appropriate one
-            const List<FixedList<label,2> >& aF = map.addedFaceList();
+            const List<objectMap>& aF = map.addedFaceList();
 
             forAll(aF, faceI)
             {
                 if
                 (
-                    (owner_[aF[faceI][0]] == cIndex) &&
-                    (aF[faceI][0] != fIndex)
+                    (owner_[aF[faceI].index()] == cIndex) &&
+                    (aF[faceI].index() != fIndex)
                 )
                 {
-                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
                         statistics_[7]++;
                     }
@@ -2115,6 +2724,12 @@ void dynamicTopoFvMesh::remove2DSlivers()
 
     // Clear out the list
     thresholdSlivers_.clear();
+
+    // If coupled patches exist, reset the flag
+    if (patchCoupling_.size() || procIndices_.size())
+    {
+        unsetCoupledModification();
+    }
 }
 
 
@@ -2231,7 +2846,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
     {
         // Region R0: Cap cell.
         map.type() = 2;
-        map.apexPoint() = fourthPoint;
+        map.add("apexPoint", fourthPoint);
 
         faceToCheck[0] = tFace[0];
         faceToCheck[1] = tFace[1];
@@ -2275,7 +2890,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
     {
         // Region R4: Cap cell.
         map.type() = 2;
-        map.apexPoint() = tFace[0];
+        map.add("apexPoint", tFace[0]);
 
         faceToCheck[0] = tFace[1];
         faceToCheck[1] = tFace[2];
@@ -2286,7 +2901,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
     {
         // Region R5: Cap cell.
         map.type() = 2;
-        map.apexPoint() = tFace[1];
+        map.add("apexPoint", tFace[1]);
 
         faceToCheck[0] = tFace[2];
         faceToCheck[1] = tFace[0];
@@ -2297,7 +2912,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
     {
         // Region R6: Cap cell.
         map.type() = 2;
-        map.apexPoint() = tFace[2];
+        map.add("apexPoint", tFace[2]);
 
         faceToCheck[0] = tFace[0];
         faceToCheck[1] = tFace[1];
@@ -2332,7 +2947,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
         {
             // Spade case: Too close to edge vector r1
             map.type() = 3;
-            map.apexPoint() = fourthPoint;
+            map.add("apexPoint", fourthPoint);
 
             edgeToCheck[0][0] = tFace[0];
             edgeToCheck[0][1] = tFace[1];
@@ -2354,7 +2969,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
         {
             // Spade case: Too close to edge vector r2
             map.type() = 3;
-            map.apexPoint() = fourthPoint;
+            map.add("apexPoint", fourthPoint);
 
             edgeToCheck[0][0] = tFace[1];
             edgeToCheck[0][1] = tFace[2];
@@ -2367,7 +2982,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
         {
             // Spade case: Too close to edge vector r3
             map.type() = 3;
-            map.apexPoint() = fourthPoint;
+            map.add("apexPoint", fourthPoint);
 
             edgeToCheck[0][0] = tFace[2];
             edgeToCheck[0][1] = tFace[0];
@@ -2392,14 +3007,14 @@ const changeMap dynamicTopoFvMesh::identifySliverType
 
                     if (thisEdge == edgeToCheck[0])
                     {
-                        map.firstEdge() = fEdges[edgeI];
+                        map.add("firstEdge", fEdges[edgeI]);
 
                         foundEdge[0] = true;
                     }
 
                     if (thisEdge == edgeToCheck[1])
                     {
-                        map.secondEdge() = fEdges[edgeI];
+                        map.add("secondEdge", fEdges[edgeI]);
 
                         foundEdge[1] = true;
                     }
@@ -2423,7 +3038,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
 
                 if (triFace::compare(triFace(thisFace), triFace(faceToCheck)))
                 {
-                    map.opposingFace() = cellToCheck[faceI];
+                    map.add("opposingFace", cellToCheck[faceI]);
 
                     break;
                 }
@@ -2448,7 +3063,7 @@ const changeMap dynamicTopoFvMesh::identifySliverType
 
                     if (thisEdge == edgeToCheck[0])
                     {
-                        map.firstEdge() = fEdges[edgeI];
+                        map.add("firstEdge", fEdges[edgeI]);
 
                         foundEdge = true;
                     }
@@ -2478,9 +3093,9 @@ const changeMap dynamicTopoFvMesh::identifySliverType
 
     if (debug > 2)
     {
-        Pout << "Cell: " << cIndex
-             << " Identified sliver type as: "
-             << map.type() << endl;
+        Pout<< "Cell: " << cIndex
+            << " Identified sliver type as: "
+            << map.type() << endl;
     }
 
     // Return the result.
@@ -2517,6 +3132,12 @@ void dynamicTopoFvMesh::removeSlivers()
         return;
     }
 
+    // If coupled patches exist, set the flag
+    if (patchCoupling_.size() || procIndices_.size())
+    {
+        setCoupledModification();
+    }
+
     // Sort by sliver-quality.
     labelList cIndices(thresholdSlivers_.toc());
     SortableList<scalar> values(cIndices.size());
@@ -2534,15 +3155,15 @@ void dynamicTopoFvMesh::removeSlivers()
 
     if (debug && thresholdSlivers_.size())
     {
-        Info << "Sliver list: " << endl;
+        Pout<< "Sliver list: " << endl;
 
         forAll(indices, indexI)
         {
             label cIndex = cIndices[indices[indexI]];
 
-            Info << " Cell: " << cIndex
-                 << " Quality: " << thresholdSlivers_[cIndex]
-                 << endl;
+            Pout<< " Cell: " << cIndex
+                << " Quality: " << thresholdSlivers_[cIndex]
+                << endl;
         }
 
         if (debug > 1)
@@ -2556,6 +3177,40 @@ void dynamicTopoFvMesh::removeSlivers()
         // Fetch the cell index
         label cIndex = cIndices[indices[indexI]];
 
+        // First check if this sliver cell is handled elsewhere.
+        if (procIndices_.size())
+        {
+            bool foundInSubMesh = false;
+
+            forAll(procIndices_, procI)
+            {
+                label proc = procIndices_[procI];
+
+                if (proc < Pstream::myProcNo())
+                {
+                    Map<label>& rCellMap =
+                    (
+                        sendMeshes_[proc].map().reverseEntityMap
+                        (
+                            coupleMap::CELL
+                        )
+                    );
+
+                    if (rCellMap.found(cIndex))
+                    {
+                        // This cell was sent to another sub-domain.
+                        foundInSubMesh = true;
+                        break;
+                    }
+                }
+            }
+
+            if (foundInSubMesh)
+            {
+                continue;
+            }
+        }
+
         // Identify the sliver type.
         changeMap map = identifySliverType(cIndex);
 
@@ -2584,8 +3239,8 @@ void dynamicTopoFvMesh::removeSlivers()
             {
                 // Sliver cell.
                 // Determine which edges need to be bisected.
-                label firstEdge = map.firstEdge();
-                label secondEdge = map.secondEdge();
+                label firstEdge = readLabel(map.lookup("firstEdge"));
+                label secondEdge = readLabel(map.lookup("secondEdge"));
 
                 // Force bisection on both edges.
                 changeMap firstMap  = bisectEdge(firstEdge, false, true);
@@ -2596,18 +3251,18 @@ void dynamicTopoFvMesh::removeSlivers()
                 // through recently added edges and compare.
                 edge edgeToCheck
                 (
-                    firstMap.addedPointList()[0][0],
-                    secondMap.addedPointList()[0][0]
+                    firstMap.addedPointList()[0].index(),
+                    secondMap.addedPointList()[0].index()
                 );
 
                 bool foundCollapseEdge = false;
 
-                const List<FixedList<label,2> >& firstMapEdges =
+                const List<objectMap>& firstMapEdges =
                 (
                     firstMap.addedEdgeList()
                 );
 
-                const List<FixedList<label,2> >& secondMapEdges =
+                const List<objectMap>& secondMapEdges =
                 (
                     secondMap.addedEdgeList()
                 );
@@ -2617,7 +3272,7 @@ void dynamicTopoFvMesh::removeSlivers()
                 {
                     const edge& thisEdge =
                     (
-                        edges_[firstMapEdges[edgeI][0]]
+                        edges_[firstMapEdges[edgeI].index()]
                     );
 
                     if (thisEdge == edgeToCheck)
@@ -2627,7 +3282,7 @@ void dynamicTopoFvMesh::removeSlivers()
                         (
                             collapseEdge
                             (
-                                firstMapEdges[edgeI][0],
+                                firstMapEdges[edgeI].index(),
                                 -1,
                                 false,
                                 true
@@ -2649,7 +3304,7 @@ void dynamicTopoFvMesh::removeSlivers()
                     {
                         const edge& thisEdge =
                         (
-                            edges_[secondMapEdges[edgeI][0]]
+                            edges_[secondMapEdges[edgeI].index()]
                         );
 
                         if (thisEdge == edgeToCheck)
@@ -2659,7 +3314,7 @@ void dynamicTopoFvMesh::removeSlivers()
                             (
                                 collapseEdge
                                 (
-                                    secondMapEdges[edgeI][0],
+                                    secondMapEdges[edgeI].index(),
                                     -1,
                                     false,
                                     true
@@ -2680,7 +3335,7 @@ void dynamicTopoFvMesh::removeSlivers()
             case 2:
             {
                 // Cap cell.
-                label opposingFace = map.opposingFace();
+                label opposingFace = readLabel(map.lookup("opposingFace"));
 
                 // Force trisection of the opposing face.
                 changeMap faceMap =
@@ -2693,18 +3348,18 @@ void dynamicTopoFvMesh::removeSlivers()
                 // through recently added edges and compare.
                 edge edgeToCheck
                 (
-                    map.apexPoint(),
-                    faceMap.addedPointList()[0][0]
+                    readLabel(map.lookup("apexPoint")),
+                    faceMap.addedPointList()[0].index()
                 );
 
-                const List<FixedList<label,2> >& faceMapEdges =
+                const List<objectMap>& faceMapEdges =
                 (
                     faceMap.addedEdgeList()
                 );
 
                 forAll(faceMapEdges, edgeI)
                 {
-                    const edge& thisEdge = edges_[faceMapEdges[edgeI][0]];
+                    const edge& thisEdge = edges_[faceMapEdges[edgeI].index()];
 
                     if (thisEdge == edgeToCheck)
                     {
@@ -2713,7 +3368,7 @@ void dynamicTopoFvMesh::removeSlivers()
                         (
                             collapseEdge
                             (
-                                faceMapEdges[edgeI][0],
+                                faceMapEdges[edgeI].index(),
                                 -1,
                                 false,
                                 true
@@ -2737,7 +3392,12 @@ void dynamicTopoFvMesh::removeSlivers()
                 // Force bisection on the first edge.
                 changeMap firstMap =
                 (
-                    bisectEdge(map.firstEdge(), false, true)
+                    bisectEdge
+                    (
+                        readLabel(map.lookup("firstEdge")),
+                        false,
+                        true
+                    )
                 );
 
                 // Collapse the intermediate edge.
@@ -2745,11 +3405,11 @@ void dynamicTopoFvMesh::removeSlivers()
                 // through recently added edges and compare.
                 edge edgeToCheck
                 (
-                    map.apexPoint(),
-                    firstMap.addedPointList()[0][0]
+                    readLabel(map.lookup("apexPoint")),
+                    firstMap.addedPointList()[0].index()
                 );
 
-                const List<FixedList<label,2> >& firstMapEdges =
+                const List<objectMap>& firstMapEdges =
                 (
                     firstMap.addedEdgeList()
                 );
@@ -2757,7 +3417,7 @@ void dynamicTopoFvMesh::removeSlivers()
                 // Loop through the first list.
                 forAll(firstMapEdges, edgeI)
                 {
-                    const edge& thisEdge = edges_[firstMapEdges[edgeI][0]];
+                    const edge& thisEdge = edges_[firstMapEdges[edgeI].index()];
 
                     if (thisEdge == edgeToCheck)
                     {
@@ -2766,7 +3426,7 @@ void dynamicTopoFvMesh::removeSlivers()
                         (
                             collapseEdge
                             (
-                                firstMapEdges[edgeI][0],
+                                firstMapEdges[edgeI].index(),
                                 -1,
                                 false,
                                 true
@@ -2792,7 +3452,7 @@ void dynamicTopoFvMesh::removeSlivers()
                 (
                     collapseEdge
                     (
-                        map.firstEdge(),
+                        readLabel(map.lookup("firstEdge")),
                         -1,
                         false,
                         true
@@ -2823,6 +3483,331 @@ void dynamicTopoFvMesh::removeSlivers()
 
     // Clear out the list
     thresholdSlivers_.clear();
+
+    // If coupled patches exist, reset the flag
+    if (patchCoupling_.size() || procIndices_.size())
+    {
+        unsetCoupledModification();
+    }
+}
+
+
+// Given an input quad-face, determine checkEdges from mesh
+//  - Does not refer to member data directly,
+//    since this is also used by subMeshes
+void dynamicTopoFvMesh::getCheckEdges
+(
+    const label fIndex,
+    const dynamicTopoFvMesh& mesh,
+    changeMap& map,
+    FixedList<edge,4>& checkEdge,
+    FixedList<label,4>& checkEdgeIndex
+)
+{
+    checkEdgeIndex[0] = mesh.getTriBoundaryEdge(fIndex);
+    checkEdge[0] = mesh.edges_[checkEdgeIndex[0]];
+
+    const labelList& fEdges = mesh.faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        if (checkEdgeIndex[0] != fEdges[edgeI])
+        {
+            const edge& thisEdge = mesh.edges_[fEdges[edgeI]];
+
+            if
+            (
+                checkEdge[0].start() == thisEdge[0] ||
+                checkEdge[0].start() == thisEdge[1]
+            )
+            {
+                checkEdgeIndex[1] = fEdges[edgeI];
+                checkEdge[1] = thisEdge;
+
+                // Update the map
+                map.add("firstEdge", checkEdgeIndex[1]);
+            }
+            else
+            if
+            (
+                checkEdge[0].end() == thisEdge[0] ||
+                checkEdge[0].end() == thisEdge[1]
+            )
+            {
+                checkEdgeIndex[2] = fEdges[edgeI];
+                checkEdge[2] = thisEdge;
+
+                // Update the map
+                map.add("secondEdge", checkEdgeIndex[2]);
+            }
+            else
+            {
+                checkEdgeIndex[3] = fEdges[edgeI];
+                checkEdge[3] = thisEdge;
+            }
+        }
+    }
+}
+
+
+// Return length-scale at an face-location in the mesh [2D]
+scalar dynamicTopoFvMesh::faceLengthScale
+(
+    const label fIndex
+) const
+{
+    // Reset the scale first
+    scalar scale = 0.0;
+
+    label facePatch = whichPatch(fIndex);
+
+    // Determine whether the face is internal
+    if (facePatch < 0)
+    {
+        scale =
+        (
+            0.5 *
+            (
+                lengthScale_[owner_[fIndex]]
+              + lengthScale_[neighbour_[fIndex]]
+            )
+        );
+    }
+    else
+    {
+        // Fetch the fixed-length scale
+        scale = lengthEstimator().fixedLengthScale(fIndex, facePatch);
+
+        // If this is a floating face, pick the owner length-scale
+        if (lengthEstimator().isFreePatch(facePatch))
+        {
+            scale = lengthScale_[owner_[fIndex]];
+        }
+
+        // If proximity-based refinement is requested,
+        // test the proximity to the nearest non-neighbour.
+        if (lengthEstimator().isProximityPatch(facePatch))
+        {
+            label proximityFace = -1;
+
+            // Perform a proximity-check.
+            scalar distance = testProximity(fIndex, proximityFace);
+
+            if (debug > 3 && self() == 0)
+            {
+                if
+                (
+                    (proximityFace > -1) &&
+                    ((distance / 5.0) < scale)
+                )
+                {
+                    Pout<< " Closest opposing face detected for face: " << nl
+                        << '\t' << fIndex
+                        << " :: " << faces_[fIndex]
+                        << " was face:\n"
+                        << '\t' << proximityFace
+                        << " :: " << polyMesh::faces()[proximityFace] << nl
+                        << " with distance: " << distance
+                        << endl;
+                }
+            }
+
+            scale =
+            (
+                Foam::min
+                (
+                    scale,
+                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
+                )
+            );
+        }
+
+        // If this face lies on a processor patch,
+        // fetch lengthScale info from patchSubMeshes
+        if (processorCoupledEntity(fIndex))
+        {
+            scale = processorLengthScale(fIndex);
+        }
+
+        // Limit scales if necessary
+        lengthEstimator().limitScale(scale);
+    }
+
+    return scale;
+}
+
+
+// Compute length-scale at an edge-location in the mesh [3D]
+scalar dynamicTopoFvMesh::edgeLengthScale
+(
+    const label eIndex
+) const
+{
+    // Reset the scale first
+    scalar scale = 0.0;
+
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    label edgePatch = whichEdgePatch(eIndex);
+
+    // Determine whether the edge is internal
+    if (edgePatch < 0)
+    {
+        forAll(eFaces, faceI)
+        {
+            scale += lengthScale_[owner_[eFaces[faceI]]];
+            scale += lengthScale_[neighbour_[eFaces[faceI]]];
+        }
+
+        scale /= (2.0*eFaces.size());
+    }
+    else
+    {
+        // Search for boundary faces, and average their scale
+        forAll(eFaces, faceI)
+        {
+            label facePatch = whichPatch(eFaces[faceI]);
+
+            // Skip internal faces
+            if (facePatch == -1)
+            {
+                continue;
+            }
+
+            // If this is a floating face, pick the owner length-scale
+            if (lengthEstimator().isFreePatch(facePatch))
+            {
+                scale += lengthScale_[owner_[eFaces[faceI]]];
+            }
+            else
+            {
+                // Fetch fixed length-scale
+                scale +=
+                (
+                    lengthEstimator().fixedLengthScale
+                    (
+                        eFaces[faceI],
+                        facePatch
+                    )
+                );
+            }
+        }
+
+        scale *= 0.5;
+
+        // If proximity-based refinement is requested,
+        // test the proximity to the nearest non-neighbour.
+        if (lengthEstimator().isProximityPatch(edgePatch))
+        {
+            label proximityFace = -1;
+
+            // Perform a proximity-check.
+            scalar distance = testProximity(eIndex, proximityFace);
+
+            if (debug > 3 && self() == 0)
+            {
+                if
+                (
+                    (proximityFace > -1) &&
+                    ((distance / 5.0) < scale)
+                )
+                {
+                    Pout<< " Closest opposing face detected for edge: " << nl
+                        << '\t' << eIndex
+                        << " :: " << edges_[eIndex]
+                        << " was face:\n"
+                        << '\t' << proximityFace
+                        << " :: " << polyMesh::faces()[proximityFace] << nl
+                        << " with distance: " << distance
+                        << endl;
+                }
+            }
+
+            scale =
+            (
+                Foam::min
+                (
+                    scale,
+                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
+                )
+            );
+        }
+
+        // If curvature-based refinement is requested,
+        // test the variation in face-normal directions.
+        if (lengthEstimator().isCurvaturePatch(edgePatch))
+        {
+            // Obtain face-normals for both faces.
+            label count = 0;
+            FixedList<vector, 2> fNorm;
+
+            forAll(eFaces, faceI)
+            {
+                if (neighbour_[eFaces[faceI]] == -1)
+                {
+                    // Obtain the normal.
+                    fNorm[count] = faces_[eFaces[faceI]].normal(points_);
+
+                    // Normalize it.
+                    fNorm[count] /= mag(fNorm[count]);
+
+                    count++;
+                }
+            }
+
+            scalar deviation = (fNorm[0] & fNorm[1]);
+            scalar refDeviation = lengthEstimator().curvatureDeviation();
+
+            if (mag(deviation) < refDeviation)
+            {
+                // Fetch the edge
+                const edge& edgeToCheck = edges_[eIndex];
+
+                // Get the edge-length.
+                scalar length =
+                (
+                    linePointRef
+                    (
+                        points_[edgeToCheck.start()],
+                        points_[edgeToCheck.end()]
+                    ).mag()
+                );
+
+                if (debug > 3 && self() == 0)
+                {
+                    Pout<< "Deviation: " << deviation << nl
+                        << "curvatureDeviation: " << refDeviation
+                        << ", Edge: " << eIndex << ", Length: " << length
+                        << ", Scale: " << scale << nl
+                        << " Half-length: " << (0.5*length) << nl
+                        << " MinRatio: "
+                        << (lengthEstimator().ratioMin()*scale)
+                        << endl;
+                }
+
+                scale =
+                (
+                    Foam::min
+                    (
+                        scale,
+                        ((length - SMALL)/lengthEstimator().ratioMax())
+                    )
+                );
+            }
+        }
+
+        // If this edge lies on a processor patch,
+        // fetch lengthScale info from patchSubMeshes
+        if (processorCoupledEntity(eIndex))
+        {
+            scale = processorLengthScale(eIndex);
+        }
+
+        // Limit scales if necessary
+        lengthEstimator().limitScale(scale);
+    }
+
+    return scale;
 }
 
 
@@ -2835,6 +3820,12 @@ void dynamicTopoFvMesh::threadedTopoModifier()
     // Coupled entities to avoid during normal modification
     labelHashSet entities;
 
+    // Handle coupled patches.
+    handleCoupledPatches(entities);
+
+    // Handle layer addition / removal
+    handleLayerAdditionRemoval();
+
     // Set the thread scheduling sequence
     labelList topoSequence(threader_->getNumThreads());
 
@@ -2858,9 +3849,12 @@ void dynamicTopoFvMesh::threadedTopoModifier()
         // Set the master thread to implement modifications
         edgeRefinementEngine(&(handlerPtr_[0]));
 
+        // Handle mesh slicing events, if necessary
+        handleMeshSlicing();
+
         if (debug)
         {
-            Info << nl << "Edge Bisection/Collapse complete." << endl;
+            Info<< nl << "Edge Bisection/Collapse complete." << endl;
         }
     }
 
@@ -2892,8 +3886,11 @@ void dynamicTopoFvMesh::threadedTopoModifier()
 
     if (debug)
     {
-        Info << nl << "Edge Swapping complete." << endl;
+        Info<< nl << "Edge Swapping complete." << endl;
     }
+
+    // Synchronize coupled patches
+    syncCoupledPatches(entities);
 }
 
 
@@ -2908,27 +3905,57 @@ bool dynamicTopoFvMesh::resetMesh()
     if (topoChangeFlag_)
     {
         // Write out statistics
-        Info << " Bisections :: Total: " << status(3)
-             << ", Surface: " << status(5) << endl;
-        Info << " Collapses  :: Total: " << status(4)
-             << ", Surface: " << status(6) << endl;
-        Info << " Swaps      :: Total: " << status(1)
-             << ", Surface: " << status(2) << endl;
+        if (Pstream::parRun() && debug)
+        {
+            Pout<< " Bisections :: Total: " << status(3)
+                << ", Surface: " << status(5) << nl
+                << " Collapses  :: Total: " << status(4)
+                << ", Surface: " << status(6) << nl
+                << " Swaps      :: Total: " << status(1)
+                << ", Surface: " << status(2) << endl;
+        }
+        else
+        {
+            Info<< " Bisections :: Total: " << status(3)
+                << ", Surface: " << status(5) << nl
+                << " Collapses  :: Total: " << status(4)
+                << ", Surface: " << status(6) << nl
+                << " Swaps      :: Total: " << status(1)
+                << ", Surface: " << status(2) << endl;
+        }
 
         if (status(7))
         {
-            Info << " Slivers    :: " << status(7) << endl;
+            Pout<< " Slivers    :: " << status(7) << endl;
         }
 
+        // Fetch reference to mapper
+        const topoMapper& fieldMapper = mapper_();
+
+        // Set information for the mapping stage
+        //  - Must be done prior to field-transfers and mesh reset
+        fieldMapper.storeMeshInformation();
+
+        // Set up field-transfers before dealing with mapping
+        wordList fieldTypes;
+        List<wordList> fieldNames;
+        List<List<char> > sendBuffer, recvBuffer;
+
+        // Subset fields and transfer
+        initFieldTransfers
+        (
+            fieldTypes,
+            fieldNames,
+            sendBuffer,
+            recvBuffer
+        );
+
         // Set sizes for mapping
         faceWeights_.setSize(facesFromFaces_.size(), scalarField(0));
         faceCentres_.setSize(facesFromFaces_.size(), vectorField(0));
         cellWeights_.setSize(cellsFromCells_.size(), scalarField(0));
         cellCentres_.setSize(cellsFromCells_.size(), vectorField(0));
 
-        // Fetch the match tolerance for mapping
-        scalar matchTol = Foam::debug::tolerances("meshOpsMatchTol", 1e-4);
-
         // Determine if mapping is to be skipped
         // Optionally skip mapping for remeshing-only / pre-processing
         const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
@@ -2940,14 +3967,39 @@ bool dynamicTopoFvMesh::resetMesh()
             skipMapping = readBool(meshSubDict.lookup("skipMapping"));
         }
 
+        // Fetch the tolerance for mapping
+        scalar mapTol = 1e-10;
+
+        if (meshSubDict.found("mappingTol") || mandatory_)
+        {
+            mapTol = readScalar(meshSubDict.lookup("mappingTol"));
+        }
+
+        // Check if outputs are enabled on failure
+        bool mappingOutput = false;
+
+        if (meshSubDict.found("mappingOutput") || mandatory_)
+        {
+            mappingOutput = readBool(meshSubDict.lookup("mappingOutput"));
+        }
+
         clockTime mappingTimer;
 
         // Compute mapping weights for modified entities
-        threadedMapping(matchTol, skipMapping);
+        threadedMapping(mapTol, skipMapping, mappingOutput);
 
         // Print out stats
-        Info << " Mapping time: " << mappingTimer.elapsedTime()
-             << " s" << endl;
+        Info<< " Mapping time: "
+            << mappingTimer.elapsedTime() << " s"
+            << endl;
+
+        // Synchronize field transfers prior to the reOrdering stage
+        syncFieldTransfers
+        (
+            fieldTypes,
+            fieldNames,
+            recvBuffer
+        );
 
         // Obtain references to zones, if any
         pointZoneMesh& pointZones = polyMesh::pointZones();
@@ -2997,22 +4049,21 @@ bool dynamicTopoFvMesh::resetMesh()
         );
 
         // Print out stats
-        Info << " Reordering time: " << reOrderingTimer.elapsedTime()
-             << " s" << endl;
+        Info<< " Reordering time: "
+            << reOrderingTimer.elapsedTime() << " s"
+            << endl;
+
+        // Obtain the number of patches before mesh reset
+        label nOldPatches = boundaryMesh().size();
 
         // Obtain the patch-point maps before resetting the mesh
-        List<Map<label> > oldPatchPointMaps(boundaryMesh().size());
+        List<Map<label> > oldPatchPointMaps(nOldPatches);
 
         forAll(oldPatchPointMaps, patchI)
         {
             oldPatchPointMaps[patchI] = boundaryMesh()[patchI].meshPointMap();
         }
 
-        topoMapper& fieldMapper = mapper_();
-
-        // Set information for the mapping stage, prior to mesh reset
-        fieldMapper.storeMeshInformation();
-
         // Set weighting information.
         // This takes over the weight data.
         fieldMapper.setFaceWeights
@@ -3027,7 +4078,15 @@ bool dynamicTopoFvMesh::resetMesh()
             xferMove(cellCentres_)
         );
 
-        // Reset the mesh with pre-motion points
+        // If the number of patches have changed
+        // at run-time, reset boundaries first
+        if (nPatches_ != nOldPatches)
+        {
+            resetBoundaries();
+        }
+
+        // Reset the mesh, and specify a non-valid
+        // boundary to avoid globalData construction
         polyMesh::resetPrimitives
         (
             xferCopy(preMotionPoints),
@@ -3035,7 +4094,8 @@ bool dynamicTopoFvMesh::resetMesh()
             xferMove(owner),
             xferMove(neighbour),
             patchSizes_,
-            patchStarts_
+            patchStarts_,
+            false
         );
 
         // Check the dictionary to determine whether
@@ -3065,9 +4125,9 @@ bool dynamicTopoFvMesh::resetMesh()
         );
 
         // Generate mapping for points on boundary patches
-        labelListList patchPointMap(boundaryMesh().size());
+        labelListList patchPointMap(nPatches_);
 
-        for (label i = 0; i < boundaryMesh().size(); i++)
+        for (label i = 0; i < nPatches_; i++)
         {
             // Obtain new patch mesh points after reset.
             const labelList& meshPointLabels = boundaryMesh()[i].meshPoints();
@@ -3076,6 +4136,12 @@ bool dynamicTopoFvMesh::resetMesh()
 
             patchPointMap[i].setSize(meshPointLabels.size(), -1);
 
+            // Skip for newly introduced patches
+            if (i >= nOldPatches)
+            {
+                continue;
+            }
+
             forAll(meshPointLabels, pointI)
             {
                 label oldIndex = pointMap_[meshPointLabels[pointI]];
@@ -3164,12 +4230,15 @@ bool dynamicTopoFvMesh::resetMesh()
         // Update the underlying mesh, and map all related fields
         updateMesh(mpm);
 
-        // Perform a dummy movePoints to force V0 creation, if necessary
-        movePoints(mpm.preMotionPoints());
+        if (mpm.hasMotionPoints())
+        {
+            // Perform a dummy movePoints to force V0 creation
+            movePoints(mpm.preMotionPoints());
 
-        // Reset old-volumes
-        resetMotion();
-        setV0();
+            // Reset old-volumes
+            resetMotion();
+            setV0();
+        }
 
         // Correct volume fluxes on the old mesh
         fieldMapper.correctFluxes();
@@ -3177,9 +4246,12 @@ bool dynamicTopoFvMesh::resetMesh()
         // Clear mapper after use
         fieldMapper.clear();
 
-        // Now move mesh to new points and
-        // compute correct mesh-fluxes.
-        movePoints(points);
+        if (mpm.hasMotionPoints())
+        {
+            // Now move mesh to new points and
+            // compute correct mesh-fluxes.
+            movePoints(points);
+        }
 
         // Update the mesh-motion solver
         if (motionSolver_.valid())
@@ -3202,9 +4274,8 @@ bool dynamicTopoFvMesh::resetMesh()
         deletedFaces_.clear();
         deletedCells_.clear();
 
-        // Clear flipFaces / modPoints
+        // Clear flipFaces
         flipFaces_.clear();
-        modPoints_.clear();
 
         // Set new sizes for the reverse maps
         reversePointMap_.setSize(nPoints_, -7);
@@ -3220,7 +4291,7 @@ bool dynamicTopoFvMesh::resetMesh()
         nOldInternalFaces_ = nInternalFaces_;
         nOldInternalEdges_ = nInternalEdges_;
 
-        for (label i = 0; i < boundaryMesh().size(); i++)
+        for (label i = 0; i < nPatches_; i++)
         {
             oldPatchSizes_[i] = patchSizes_[i];
             oldPatchStarts_[i] = patchStarts_[i];
@@ -3229,10 +4300,35 @@ bool dynamicTopoFvMesh::resetMesh()
             oldPatchNMeshPoints_[i] = patchNMeshPoints_[i];
         }
 
-        // Basic checks for mesh-validity
-        if (debug > 2)
+        // Clear parallel structures
+        if (Pstream::parRun())
         {
-            checkMesh(true);
+            procIndices_.clear();
+            sendMeshes_.clear();
+            recvMeshes_.clear();
+        }
+
+        bool checkCplBoundaries = false;
+
+        if (meshSubDict.found("checkCoupledBoundaries") || mandatory_)
+        {
+            checkCplBoundaries =
+            (
+                readBool(meshSubDict.lookup("checkCoupledBoundaries"))
+            );
+        }
+
+        if (checkCplBoundaries)
+        {
+            bool failed = checkCoupledBoundaries();
+
+            if (failed)
+            {
+                FatalErrorIn("bool dynamicTopoFvMesh::resetMesh()")
+                    << " Coupled boundary check failed on processor: "
+                    << Pstream::myProcNo()
+                    << abort(FatalError);
+            }
         }
 
         // Reset statistics
@@ -3244,7 +4340,7 @@ bool dynamicTopoFvMesh::resetMesh()
         // Only execute mesh-motion.
         if (motionSolver_.valid())
         {
-            movePoints(motionSolver_->curPoints());
+            movePoints(points_);
         }
     }
 
@@ -3266,26 +4362,59 @@ bool dynamicTopoFvMesh::resetMesh()
 }
 
 
-// Map all fields in time using a customized mapper
-void dynamicTopoFvMesh::mapFields(const mapPolyMesh& meshMap) const
+// Update mesh corresponding to the given map
+void dynamicTopoFvMesh::updateMesh(const mapPolyMesh& mpm)
 {
+    if (coupledModification_)
+    {
+        // This bit gets called only during the load-balancing
+        // stage, since the fvMesh::updateMesh is a bit different
+        fvMesh::updateMesh(mpm);
+        return;
+    }
+
+    // Delete oldPoints in polyMesh
+    polyMesh::resetMotion();
+
+    // Clear-out fvMesh geometry and addressing
+    fvMesh::clearOut();
+
+    // Update polyMesh.
+    polyMesh::updateMesh(mpm);
+
+    // Map all fields
+    mapFields(mpm);
+}
+
+
+// Map all fields in time using a customized mapper
+void dynamicTopoFvMesh::mapFields(const mapPolyMesh& mpm) const
+{
+    if (coupledModification_)
+    {
+        // This bit gets called only during the load-balancing
+        // stage, since the fvMesh::mapFields is a bit different
+        fvMesh::mapFields(mpm);
+        return;
+    }
+
     if (debug)
     {
-        Info << "void dynamicTopoFvMesh::mapFields(const mapPolyMesh&): "
-             << "Mapping fv fields."
-             << endl;
+        Info<< "void dynamicTopoFvMesh::mapFields(const mapPolyMesh&) const: "
+            << "Mapping fv fields."
+            << endl;
     }
 
     const topoMapper& fieldMapper = mapper_();
 
     // Set the mapPolyMesh object in the mapper
-    fieldMapper.setMapper(meshMap);
+    fieldMapper.setMapper(mpm);
+
+    // Conservatively map scalar/vector volFields
+    conservativeMapVolFields<scalar>(fieldMapper);
+    conservativeMapVolFields<vector>(fieldMapper);
 
     // Map all the volFields in the objectRegistry
-    MapGeometricFields<scalar,fvPatchField,topoMapper,volMesh>
-        (fieldMapper);
-    MapGeometricFields<vector,fvPatchField,topoMapper,volMesh>
-        (fieldMapper);
     MapGeometricFields<sphericalTensor,fvPatchField,topoMapper,volMesh>
         (fieldMapper);
     MapGeometricFields<symmTensor,fvPatchField,topoMapper,volMesh>
@@ -3293,11 +4422,11 @@ void dynamicTopoFvMesh::mapFields(const mapPolyMesh& meshMap) const
     MapGeometricFields<tensor,fvPatchField,topoMapper,volMesh>
         (fieldMapper);
 
+    // Conservatively map scalar/vector surfaceFields
+    conservativeMapSurfaceFields<scalar>(fieldMapper);
+    conservativeMapSurfaceFields<vector>(fieldMapper);
+
     // Map all the surfaceFields in the objectRegistry
-    MapGeometricFields<scalar,fvsPatchField,topoMapper,surfaceMesh>
-        (fieldMapper);
-    MapGeometricFields<vector,fvsPatchField,topoMapper,surfaceMesh>
-        (fieldMapper);
     MapGeometricFields<sphericalTensor,fvsPatchField,topoMapper,surfaceMesh>
         (fieldMapper);
     MapGeometricFields<symmTensor,fvsPatchField,topoMapper,surfaceMesh>
@@ -3322,6 +4451,11 @@ bool dynamicTopoFvMesh::update()
     {
         points_ = motionSolver_->newPoints()();
     }
+    else
+    {
+        // Set point positions from mesh
+        points_ = polyMesh::points();
+    }
 
     // Obtain mesh stats before topo-changes
     bool noSlivers = meshQuality(true);
@@ -3343,9 +4477,9 @@ bool dynamicTopoFvMesh::update()
     // Invoke the threaded topoModifier
     threadedTopoModifier();
 
-    Info << " Topo modifier time: "
-         << topoTimer.elapsedTime() << " s"
-         << endl;
+    Info<< " Topo modifier time: "
+        << topoTimer.elapsedTime() << " s"
+        << endl;
 
     // Apply all topology changes (if any) and reset mesh.
     return resetMesh();
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
index e4256d135..c35b5208c 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
@@ -37,6 +37,7 @@ SourceFiles
     dynamicTopoFvMesh.C
     dynamicTopoFvMeshI.H
     dynamicTopoFvMeshCheck.C
+    dynamicTopoFvMeshCoupled.C
     dynamicTopoFvMeshReOrder.C
     dynamicTopoFvMeshMapping.C
     edgeBisect.C
@@ -50,6 +51,7 @@ SourceFiles
 
 #include "Switch.H"
 #include "tetMetric.H"
+#include "topoMapper.H"
 #include "DynamicField.H"
 #include "threadHandler.H"
 #include "dynamicFvMesh.H"
@@ -64,8 +66,9 @@ class eMesh;
 class Stack;
 class changeMap;
 class objectMap;
-class topoMapper;
+class coupledInfo;
 class motionSolver;
+class convexSetAlgorithm;
 class lengthScaleEstimator;
 
 /*---------------------------------------------------------------------------*\
@@ -78,9 +81,18 @@ class dynamicTopoFvMesh
 {
     // Private data
 
+        //- Reference to base mesh
+        const dynamicTopoFvMesh& baseMesh_;
+
+        //- Number of boundary patches
+        label nPatches_;
+
         //- Topology change flag
         bool topoChangeFlag_;
 
+        //- Is this a subMesh?
+        bool isSubMesh_;
+
         //- Dynamic mesh dictionary
         IOdictionary dict_;
 
@@ -94,9 +106,15 @@ class dynamicTopoFvMesh
         //- Edge refinement switch
         Switch edgeRefinement_;
 
+        //- Load motion solver
+        Switch loadMotionSolver_;
+
         //- Switch for cell-bandwidth reduction
         Switch bandWidthReduction_;
 
+        //- Coupled modification switch
+        mutable Switch coupledModification_;
+
         //- Specify the re-meshing interval
         label interval_;
 
@@ -119,27 +137,21 @@ class dynamicTopoFvMesh
         //     support template typedefs,
         //     so this is a work-around
         template <class T>
-        class resizableList
+        class resizable
         {
         public:
-            typedef DynamicList<T, 0, 11, 10> Type;
+            typedef DynamicList<T, 0, 11, 10> ListType;
+            typedef DynamicField<T, 0, 11, 10> FieldType;
         };
 
-        template <class T>
-        class resizableField
-        {
-        public:
-            typedef DynamicField<T> Type;
-        };
-
-        resizableField<point>::Type oldPoints_, points_;
-        resizableList<face>::Type faces_;
-        resizableList<label>::Type owner_, neighbour_;
-        resizableList<cell>::Type cells_;
-        resizableList<edge>::Type edges_;
-        resizableList<labelList>::Type pointEdges_, edgePoints_;
-        resizableList<labelList>::Type edgeFaces_, faceEdges_;
-        resizableList<scalar>::Type lengthScale_;
+        resizable<point>::FieldType oldPoints_, points_;
+        resizable<face>::ListType faces_;
+        resizable<label>::ListType owner_, neighbour_;
+        resizable<cell>::ListType cells_;
+        resizable<edge>::ListType edges_;
+        resizable<labelList>::ListType pointEdges_;
+        resizable<labelList>::ListType edgeFaces_, faceEdges_;
+        resizable<scalar>::ListType lengthScale_;
 
         //- Size information
         labelList oldPatchSizes_, patchSizes_;
@@ -181,6 +193,7 @@ class dynamicTopoFvMesh
         Map<labelList> faceParents_;
         List<scalarField> faceWeights_;
         List<vectorField> faceCentres_;
+
         Map<labelList> cellParents_;
         List<scalarField> cellWeights_;
         List<vectorField> cellCentres_;
@@ -201,9 +214,8 @@ class dynamicTopoFvMesh
         labelHashSet deletedFaces_;
         labelHashSet deletedCells_;
 
-        //- List of flipped faces / modified old-points
+        //- List of flipped faces
         labelHashSet flipFaces_;
-        Map<labelList> modPoints_;
 
         //- Run-time statistics
         label maxModifications_;
@@ -237,11 +249,42 @@ class dynamicTopoFvMesh
         // in multi-threaded reOrdering
         FixedList<Mutex, 4> entityMutex_;
 
+        // Local coupled patch information
+        PtrList<coupledInfo> patchCoupling_;
+
+        // List of processors that this sub-domain talks to
+        labelList procIndices_;
+
+        // Sub-Mesh pointers
+        PtrList<coupledInfo> sendMeshes_;
+        PtrList<coupledInfo> recvMeshes_;
+
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
         dynamicTopoFvMesh(const dynamicTopoFvMesh&);
 
+        //- Construct from components
+        //- Used for subMeshes only.
+        dynamicTopoFvMesh
+        (
+            const dynamicTopoFvMesh& mesh,
+            const IOobject& io,
+            const Xfer<pointField>& points,
+            const Xfer<pointField>& oldPoints,
+            const Xfer<edgeList>& edges,
+            const Xfer<faceList>& faces,
+            const Xfer<labelListList>& faceEdges,
+            const Xfer<labelList>& owner,
+            const Xfer<labelList>& neighbour,
+            const labelList& faceStarts,
+            const labelList& faceSizes,
+            const labelList& edgeStarts,
+            const labelList& edgeSizes,
+            const wordList& patchNames,
+            const dictionary& patchDict
+        );
+
         //- Disallow default bitwise assignment
         void operator=(const dynamicTopoFvMesh&);
 
@@ -256,6 +299,7 @@ class dynamicTopoFvMesh
         (
             const scalar matchTol,
             const bool skipMapping,
+            const bool mappingOutput,
             const label faceStart,
             const label faceSize,
             const label cellStart,
@@ -265,19 +309,13 @@ class dynamicTopoFvMesh
         // Static equivalent for multiThreading
         static void computeMappingThread(void *argument);
 
-        // Compute parents for inverse-distance weighting
-        void computeParents
-        (
-            const label index,
-            const labelList& mapCandidates,
-            const labelListList& oldNeighbourList,
-            const vectorField& oldCentres,
-            const label dimension,
-            labelList& parents
-        ) const;
-
         // Routine to invoke threaded mapping
-        void threadedMapping(scalar matchTol, bool skipMapping);
+        void threadedMapping
+        (
+            scalar matchTol,
+            bool skipMapping,
+            bool mappingOutput
+        );
 
         // Initialize mesh edges and related connectivity lists
         void initEdges();
@@ -316,11 +354,21 @@ class dynamicTopoFvMesh
         // contains a triangular face.
         inline label getTriBoundaryEdge(const label fIndex) const;
 
+        // Given an input quad-face, determine checkEdges from mesh
+        static void getCheckEdges
+        (
+            const label fIndex,
+            const dynamicTopoFvMesh& mesh,
+            changeMap& map,
+            FixedList<edge,4>& checkEdge,
+            FixedList<label,4>& checkEdgeIndex
+        );
+
         // Return length-scale at an face-location in the mesh [2D]
-        inline scalar faceLengthScale(const label fIndex) const;
+        scalar faceLengthScale(const label fIndex) const;
 
         // Return length-scale at an edge-location in the mesh [3D]
-        inline scalar edgeLengthScale(const label eIndex) const;
+        scalar edgeLengthScale(const label eIndex) const;
 
         // Check for bisection
         inline bool checkBisection(const label index) const;
@@ -349,6 +397,13 @@ class dynamicTopoFvMesh
         // Initialize stacks
         inline void initStacks(const labelHashSet& entities);
 
+        // Initialize the coupled stack
+        void initCoupledStack
+        (
+            const labelHashSet& entities,
+            bool useEntities
+        );
+
         // Method to determine the boundary patch index for a given face
         inline label whichPatch(const label index) const;
 
@@ -385,13 +440,6 @@ class dynamicTopoFvMesh
             bool forceOp = false
         );
 
-        // Method for the swapping of an edge in 3D
-        void swapEdge
-        (
-            const label eIndex,
-            bool forceOp = false
-        );
-
         // Method for the bisection of an edge in 3D
         const changeMap
         bisectEdge
@@ -420,6 +468,9 @@ class dynamicTopoFvMesh
             bool forceOp = false
         );
 
+        // Slice the mesh at a particular location
+        void sliceMesh(const labelPair& pointPair);
+
         // Utility method to check for invalid face-bisection.
         bool checkBisection
         (
@@ -429,8 +480,9 @@ class dynamicTopoFvMesh
         ) const;
 
         // Utility method to check for invalid face-collapse.
-        bool checkCollapse
+        static bool checkCollapse
         (
+            const dynamicTopoFvMesh& mesh,
             const labelList& triFaces,
             const FixedList<label,2>& c0BdyIndex,
             const FixedList<label,2>& c1BdyIndex,
@@ -440,7 +492,7 @@ class dynamicTopoFvMesh
             scalar& collapseQuality,
             const bool checkNeighbour,
             bool forceOp = false
-        ) const;
+        );
 
         // Utility method to check for invalid edge-collapse.
         bool checkCollapse
@@ -449,7 +501,7 @@ class dynamicTopoFvMesh
             const point& oldPoint,
             const label pointIndex,
             const label cellIndex,
-            labelHashSet& cellsChecked,
+            DynamicList<label>& cellsChecked,
             scalar& collapseQuality,
             bool forceOp = false
         ) const;
@@ -491,7 +543,9 @@ class dynamicTopoFvMesh
         removeCells
         (
             const labelList& cList,
-            const label patch
+            const label patch,
+            const word& rcName,
+            bool checkOnly = false
         );
 
         // Remove the specified cell from the mesh
@@ -525,13 +579,19 @@ class dynamicTopoFvMesh
             const Map<bool>& cellColors
         );
 
+        // Merge a set of boundary faces into internal
+        const changeMap
+        mergeBoundaryFaces
+        (
+            const labelList& mergeFaces
+        );
+
         // Insert the specified edge to the mesh
         label insertEdge
         (
             const label patch,
             const edge& newEdge,
-            const labelList& edgeFaces,
-            const labelList& edgePoints = labelList::null()
+            const labelList& edgeFaces
         );
 
         // Remove the specified edge from the mesh
@@ -555,12 +615,13 @@ class dynamicTopoFvMesh
             const label pIndex
         );
 
-        // Utility method to build edgePoints for an edge [3D]
-        void buildEdgePoints
+        // Utility method to build vertexHull for an edge [3D]
+        void buildVertexHull
         (
             const label eIndex,
+            labelList& vertexHull,
             const label checkIndex = 0
-        );
+        ) const;
 
         // Utility to check whether points of an edge lie on a boundary
         const FixedList<bool,2> checkEdgeBoundary(const label eIndex) const;
@@ -569,7 +630,20 @@ class dynamicTopoFvMesh
         inline void setFlip(const label fIndex);
 
         // Utility method to compute the minimum quality of a vertex hull
-        scalar computeMinQuality(const label eIndex) const;
+        scalar computeMinQuality
+        (
+            const label eIndex,
+            labelList& hullVertices
+        ) const;
+
+        // Compute minQuality given addressing
+        scalar computeMinQuality
+        (
+            const edge& edgeToCheck,
+            const labelList& hullVertices,
+            const UList<point>& points,
+            bool closedRing = false
+        ) const;
 
         // Utility method to compute the quality of a vertex hull
         // around an edge after bisection.
@@ -580,7 +654,12 @@ class dynamicTopoFvMesh
         scalar computeTrisectionQuality(const label fIndex) const;
 
         // Check whether the given edge is on a bounding curve
-        bool checkBoundingCurve(const label eIndex) const;
+        bool checkBoundingCurve
+        (
+            const label eIndex,
+            const bool overRidePurityCheck = false,
+            label* nProcCurves = NULL
+        ) const;
 
         // Allocate dynamic programming tables
         void initTables
@@ -606,14 +685,28 @@ class dynamicTopoFvMesh
         bool fillTables
         (
             const label eIndex,
-            const scalar minQuality,
+            scalar& minQuality,
             labelList& m,
+            labelList& hullVertices,
             PtrList<scalarListList>& Q,
             PtrList<labelListList>& K,
             PtrList<labelListList>& triangulations,
             const label checkIndex = 0
         ) const;
 
+        // Fill tables given addressing
+        void fillTables
+        (
+            const edge& edgeToCheck,
+            const scalar minQuality,
+            const label m,
+            const labelList& hullVertices,
+            const UList<point>& points,
+            scalarListList& Q,
+            labelListList& K,
+            labelListList& triangulations
+        ) const;
+
         // Print out tables for debugging
         void printTables
         (
@@ -629,7 +722,9 @@ class dynamicTopoFvMesh
         (
             const label eIndex,
             const scalar minQuality,
-            const PtrList<labelListList>& K,
+            const labelList& hullVertices,
+            PtrList<scalarListList>& Q,
+            PtrList<labelListList>& K,
             PtrList<labelListList>& triangulations,
             const label checkIndex = 0
         );
@@ -649,7 +744,8 @@ class dynamicTopoFvMesh
         (
             const label eIndex,
             const labelList& hullVertices,
-            const labelListList& triangulations
+            const labelListList& triangulations,
+            bool output = false
         ) const;
 
         // Check old-volumes for the configuration.
@@ -781,6 +877,9 @@ class dynamicTopoFvMesh
         // Reset the mesh and generate mapping information
         bool resetMesh();
 
+        // Write out connectivity for an edge
+        void writeEdgeConnectivity(const label eIndex) const;
+
         // Output an entity as a VTK file
         void writeVTK
         (
@@ -798,7 +897,9 @@ class dynamicTopoFvMesh
             const labelList& cList,
             const label primitiveType = 3,
             const bool useOldConnectivity = false,
-            const bool useOldPoints = false
+            const bool useOldPoints = false,
+            const UList<scalar>& scalField = UList<scalar>(),
+            const UList<label>& lablField = UList<label>()
         ) const;
 
         // Return the status report interval
@@ -807,6 +908,18 @@ class dynamicTopoFvMesh
         // Check the state of local connectivity lists
         void checkConnectivity(const label maxErrors = 0) const;
 
+        // Handle mesh slicing events.
+        void handleMeshSlicing();
+
+        // Handle layer addition / removal events
+        void handleLayerAdditionRemoval();
+
+        // Add cell layer above specified patch
+        const changeMap addCellLayer(const label patchID);
+
+        // Remove cell layer above specified patch
+        const changeMap removeCellLayer(const label patchID);
+
         // Test an edge / face for proximity with other non-neighbouring faces.
         // Return the scalar distance to the nearest face.
         scalar testProximity
@@ -818,9 +931,165 @@ class dynamicTopoFvMesh
         // Calculate the edge length-scale for the mesh
         void calculateLengthScale(bool dump = false);
 
+        // Fill buffers with length-scale info
+        // and exchange across processors.
+        void exchangeLengthBuffers();
+
+        // Implementing the fillTables operation for coupled edges
+        bool coupledFillTables
+        (
+            const label eIndex,
+            scalar& minQuality,
+            labelList& m,
+            PtrList<scalarListList>& Q,
+            PtrList<labelListList>& K,
+            PtrList<labelListList>& triangulations
+        ) const;
+
+        // Additional mapping contributions for coupled entities
+        void computeCoupledWeights
+        (
+            const label index,
+            const label dimension,
+            labelList& parents,
+            scalarField& weights,
+            vectorField& centres,
+            bool output = false
+        );
+
+        // Fetch length-scale info for processor entities
+        scalar processorLengthScale(const label index) const;
+
+        // Method to determine whether the master entity is locally coupled
+        bool locallyCoupledEntity
+        (
+            const label index,
+            bool checkSlaves = false,
+            bool checkProcs = true,
+            bool checkFace = false
+        ) const;
+
+        // Method to determine the locally coupled patch index
+        label locallyCoupledEdgePatch(const label eIndex) const;
+
+        // Method to determine if the entity is on a processor boundary
+        bool processorCoupledEntity
+        (
+            const label index,
+            bool checkFace = false,
+            bool checkEdge = false,
+            bool checkPure = false,
+            FixedList<label, 2>* patchLabels = NULL,
+            FixedList<vector, 2>* patchNormals = NULL
+        ) const;
+
         // Read optional dictionary parameters
         void readOptionalParameters(bool reRead = false);
 
+        // Execute load balancing operations on the mesh
+        void executeLoadBalancing(const dictionary& balanceDict);
+
+        // Identify coupled patches.
+        bool identifyCoupledPatches();
+
+        // Read coupled patch information from dictionary.
+        void readCoupledPatches();
+
+        // Initialize coupled patch connectivity for topology modifications.
+        static void initCoupledConnectivity(void *argument);
+
+        // Move coupled subMesh points
+        void moveCoupledSubMeshes();
+
+        // Build a list of entities that need to be avoided
+        // by regular topo-changes.
+        void buildEntitiesToAvoid
+        (
+            labelHashSet& entities,
+            bool checkSubMesh
+        );
+
+        // Check whether the specified edge is a coupled master edge.
+        bool isCoupledMaster(const label eIndex) const;
+
+        // Set coupled modification
+        void setCoupledModification() const;
+
+        // Unset coupled modification
+        void unsetCoupledModification() const;
+
+        // Insert the cells around the coupled master entity to the mesh
+        const changeMap insertCells(const label mIndex);
+
+        // Handle topology changes for coupled patches
+        void handleCoupledPatches(labelHashSet& entities);
+
+        // Synchronize topology operations across processors
+        void syncCoupledPatches(labelHashSet& entities);
+
+        // Check the state of coupled boundaries
+        bool checkCoupledBoundaries(bool report = true) const;
+
+        // Build patch sub-meshes for processor patches
+        void buildProcessorPatchMeshes();
+
+        // Build patch sub-mesh for a specified processor
+        void buildProcessorPatchMesh
+        (
+            coupledInfo& subMesh,
+            Map<labelList>& commonCells
+        );
+
+        // Build coupled maps for locally coupled patches
+        void buildLocalCoupledMaps();
+
+        // Build coupled maps for coupled processor patches
+        void buildProcessorCoupledMaps();
+
+        // Introduce a new processor patch to the mesh
+        label createProcessorPatch(const label proc);
+
+        // If a patch is of processor type,
+        // get the neighbouring processor ID
+        label getNeighbourProcessor(const label patch) const;
+
+        // If the number of patches have changed during run-time,
+        // reset boundaries with new processor patches
+        void resetBoundaries();
+
+        // Initialize subMesh field transfers for mapping
+        void initFieldTransfers
+        (
+            wordList& fieldTypes,
+            List<wordList>& fieldNames,
+            List<List<char> >& sendBuffer,
+            List<List<char> >& recvBuffer
+        );
+
+        // Synchronize field transfers for mapping
+        void syncFieldTransfers
+        (
+            wordList& fieldTypes,
+            List<wordList>& fieldNames,
+            List<List<char> >& recvBuffer
+        );
+
+        // Initialize coupled boundary ordering
+        void initCoupledBoundaryOrdering
+        (
+            List<pointField>& centres,
+            List<pointField>& anchors
+        ) const;
+
+        // Synchronize coupled boundary ordering
+        bool syncCoupledBoundaryOrdering
+        (
+            List<pointField>& centres,
+            List<pointField>& anchors,
+            labelListList& faceMaps,
+            labelListList& rotations
+        ) const;
+
         // Dump cell-quality statistics
         bool meshQuality(bool outputOption);
 
@@ -840,8 +1109,11 @@ public:
 
     // Member Functions
 
+        //- Update mesh corresponding to the given map
+        virtual void updateMesh(const mapPolyMesh& mpm);
+
         // Map all fields in time using a customized mapper
-        virtual void mapFields(const mapPolyMesh& meshMap) const;
+        virtual void mapFields(const mapPolyMesh& mpm) const;
 
         // Update the mesh for motion / topology changes
         // Return true if topology changes have occurred
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
index 9d8ec2d24..c76af7ac7 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
@@ -33,7 +33,7 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 #include "dynamicTopoFvMesh.H"
 
@@ -41,6 +41,7 @@ Author
 #include "volFields.H"
 #include "triPointRef.H"
 #include "tetPointRef.H"
+#include "coupledInfo.H"
 
 namespace Foam
 {
@@ -73,6 +74,21 @@ bool dynamicTopoFvMesh::meshQuality
             continue;
         }
 
+        // Skip hexahedral cells
+        if (cellToCheck.size() == 6)
+        {
+            cQuality = 1.0;
+            meanQuality += cQuality;
+
+            // Update min / max
+            maxQuality = Foam::max(cQuality, maxQuality);
+            minQuality = Foam::min(cQuality, minQuality);
+
+            nCells++;
+
+            continue;
+        }
+
         if (twoDMesh_)
         {
             // Assume XY plane here
@@ -201,13 +217,14 @@ bool dynamicTopoFvMesh::meshQuality
                 << endl;
         }
 
-        Info << endl;
-        Info << " ~~~ Mesh Quality Statistics ~~~ " << endl;
-        Info << " Min: " << minQuality << endl;
-        Info << " Max: " << maxQuality << endl;
-        Info << " Mean: " << meanQuality/nCells << endl;
-        Info << " Cells: " << nCells << endl;
-        Info << " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ " << nl << endl;
+        Info<< nl
+            << " ~~~ Mesh Quality Statistics ~~~ " << nl
+            << " Min: " << minQuality << nl
+            << " Max: " << maxQuality << nl
+            << " Mean: " << meanQuality/nCells << nl
+            << " Cells: " << nCells << nl
+            << " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ " << nl
+            << endl;
     }
 
     return sliversAbsent;
@@ -248,11 +265,30 @@ dynamicTopoFvMesh::checkEdgeBoundary
 
 
 // Check whether the given edge is on a bounding curve
-bool dynamicTopoFvMesh::checkBoundingCurve(const label eIndex) const
+//  - If nProcCurves is provided, the variable is incremented
+//    if the edge is processor-coupled
+bool dynamicTopoFvMesh::checkBoundingCurve
+(
+    const label eIndex,
+    const bool overRidePurityCheck,
+    label* nProcCurves
+) const
 {
     // Internal edges don't count
     label edgePatch = -1;
 
+    // If this entity was deleted, skip it.
+    if (edgeFaces_[eIndex].empty())
+    {
+        // Return true so that swap3DEdges skips this edge.
+        return true;
+    }
+
+    // Check if two boundary faces lie on different face-patches
+    bool procCoupled = false;
+    FixedList<label, 2> fPatches(-1);
+    FixedList<vector, 2> fNorm(vector::zero);
+
     if ((edgePatch = whichEdgePatch(eIndex)) < 0)
     {
         return false;
@@ -264,37 +300,117 @@ bool dynamicTopoFvMesh::checkBoundingCurve(const label eIndex) const
         {
             return true;
         }
-    }
 
-    // Check if two boundary faces lie on different face-patches
-    FixedList<vector, 2> fNorm(vector::zero);
-    label fPatch, firstPatch = -1, secondPatch = -1, count = 0;
-    const labelList& edgeFaces = edgeFaces_[eIndex];
-
-    forAll(edgeFaces, faceI)
-    {
-        if ((fPatch = whichPatch(edgeFaces[faceI])) > -1)
+        // Explicit check for processor edges (both 2D and 3D)
+        if (processorCoupledEntity(eIndex, false, true))
         {
-            // Obtain the normal.
-            fNorm[count] = faces_[edgeFaces[faceI]].normal(points_);
-
-            // Normalize it.
-            fNorm[count] /= mag(fNorm[count]) + VSMALL;
-
-            count++;
-
-            if (firstPatch == -1)
+            // Increment nProcCurves
+            if (nProcCurves)
             {
-                firstPatch = fPatch;
+                (*nProcCurves)++;
+            }
+
+            // Check for pure processor edge, and if not,
+            // fetch boundary patch labels / normals
+            if
+            (
+                processorCoupledEntity
+                (
+                    eIndex,
+                    false,
+                    true,
+                    true,
+                    &fPatches,
+                    &fNorm
+                )
+            )
+            {
+                // 'Pure' processor coupled edges don't count
+                return false;
             }
             else
+            if (!overRidePurityCheck)
             {
-                secondPatch = fPatch;
-                break;
+                // This edge lies between a processor and physical patch,
+                //  - This a bounding curve (unless an override is requested)
+                //  - An override is warranted for 2-2 swaps on impure edges,
+                //    which is typically requested by swap3DEdges.
+                return true;
+            }
+
+            // Specify that the edge is procCoupled
+            procCoupled = true;
+        }
+    }
+
+    if (procCoupled)
+    {
+        // Normalize patch normals from coupled check
+        fNorm[0] /= mag(fNorm[0]) + VSMALL;
+        fNorm[1] /= mag(fNorm[1]) + VSMALL;
+    }
+    else
+    {
+        // Fetch patch indices / normals
+        const labelList& eFaces = edgeFaces_[eIndex];
+
+        label fPatch = -1, count = 0;
+
+        forAll(eFaces, faceI)
+        {
+            if ((fPatch = whichPatch(eFaces[faceI])) > -1)
+            {
+                // Obtain the normal.
+                fNorm[count] = faces_[eFaces[faceI]].normal(points_);
+
+                // Normalize it.
+                fNorm[count] /= mag(fNorm[count]) + VSMALL;
+
+                // Note patch index
+                fPatches[count] = fPatch;
+
+                count++;
+
+                if (count == 2)
+                {
+                    break;
+                }
             }
         }
     }
 
+    // Check for legitimate patches
+    if (fPatches[0] < 0 || fPatches[1] < 0)
+    {
+        const labelList& eFaces = edgeFaces_[eIndex];
+
+        forAll(eFaces, faceI)
+        {
+            Pout<< " Face: " << eFaces[faceI]
+                << " :: " << faces_[eFaces[faceI]]
+                << " Patch: " << whichPatch(eFaces[faceI]) << nl;
+        }
+
+        label epI = whichEdgePatch(eIndex);
+
+        FatalErrorIn
+        (
+            "bool dynamicTopoFvMesh::checkBoundingCurve"
+            "(const label, const bool) const"
+        )
+            << " Edge: " << eIndex << ":: " << edges_[eIndex]
+            << " Patch: "
+            << (epI < 0 ? "Internal" : boundaryMesh()[epI].name())
+            << " edgeFaces: " << eFaces << nl
+            << " expected 2 boundary patches." << nl
+            << " fPatches[0]: " << fPatches[0] << nl
+            << " fPatches[1]: " << fPatches[1] << nl
+            << " fNorm[0]: " << fNorm[0] << nl
+            << " fNorm[1]: " << fNorm[1] << nl
+            << " coupledModification: " << coupledModification_
+            << abort(FatalError);
+    }
+
     scalar deviation = (fNorm[0] & fNorm[1]);
 
     // Check if the swap-curvature is too high
@@ -304,7 +420,7 @@ bool dynamicTopoFvMesh::checkBoundingCurve(const label eIndex) const
     }
 
     // Check if the edge borders two different patches
-    if (firstPatch != secondPatch)
+    if (fPatches[0] != fPatches[1])
     {
         return true;
     }
@@ -333,11 +449,67 @@ bool dynamicTopoFvMesh::checkQuality
 
         if (debug > 2)
         {
-            Info << nl << nl
-                 << " eIndex: " << eIndex
-                 << " minQuality: " << minQuality
-                 << " newQuality: " << Q[checkIndex][0][m[checkIndex]-1]
-                 << endl;
+            Pout<< nl << nl
+                << " eIndex: " << eIndex
+                << " minQuality: " << minQuality
+                << " newQuality: " << Q[checkIndex][0][m[checkIndex]-1]
+                << endl;
+        }
+    }
+
+    if (coupledModification_)
+    {
+        // Only locally coupled indices require checks
+        if (locallyCoupledEntity(eIndex))
+        {
+            // Check the quality of the slave edge as well.
+            label sIndex = -1;
+
+            // Loop through masterToSlave and determine the slave index.
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const label edgeEnum  = coupleMap::EDGE;
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                    if ((sIndex = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "bool dynamicTopoFvMesh::checkQuality\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const labelList& m,\n"
+                    "    const PtrList<scalarListList>& Q,\n"
+                    "    const scalar minQuality,\n"
+                    "    const label checkIndex\n"
+                    ") const\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Edge: " << eIndex << nl
+                    << abort(FatalError);
+            }
+
+            // Turn off switch temporarily.
+            unsetCoupledModification();
+
+            // Recursively call for the slave edge.
+            myResult =
+            (
+                myResult && checkQuality(sIndex, m, Q, minQuality, 1)
+            );
+
+            // Turn it back on.
+            setCoupledModification();
         }
     }
 
@@ -354,68 +526,68 @@ void dynamicTopoFvMesh::printTables
     const label checkIndex
 ) const
 {
-    Info << "m: " << m[checkIndex] << endl;
+    Pout<< "m: " << m[checkIndex] << endl;
 
     // Print out Q
-    Info << "===" << endl;
-    Info << " Q " << endl;
-    Info << "===" << endl;
+    Pout<< "===" << nl
+        << " Q " << nl
+        << "===" << endl;
 
-    Info << "   ";
+    Pout<< "   ";
 
     for (label j = 0; j < m[checkIndex]; j++)
     {
-        Info << setw(12) << j;
+        Pout<< setw(12) << j;
     }
 
-    Info << nl;
+    Pout<< nl;
 
     for (label j = 0; j < m[checkIndex]; j++)
     {
-        Info << "-------------";
+        Pout<< "-------------";
     }
 
-    Info << nl;
+    Pout<< nl;
 
     for (label i = 0; i < (m[checkIndex]-2); i++)
     {
-        Info << i << ": ";
+        Pout<< i << ": ";
 
         for (label j = 0; j < m[checkIndex]; j++)
         {
-            Info << setw(12) << Q[checkIndex][i][j];
+            Pout<< setw(12) << Q[checkIndex][i][j];
         }
 
-        Info << nl;
+        Pout<< nl;
     }
 
     // Print out K
-    Info << "===" << endl;
-    Info << " K " << endl;
-    Info << "===" << endl;
+    Pout<< "===" << nl
+        << " K " << nl
+        << "===" << endl;
 
-    Info << "   ";
+    Pout<< "   ";
 
     for (label j = 0; j < m[checkIndex]; j++)
     {
-        Info << setw(12) << j;
+        Pout<< setw(12) << j;
     }
 
-    Info << nl;
+    Pout<< nl;
 
     for (label i = 0; i < (m[checkIndex]-2); i++)
     {
-        Info << i << ": ";
+        Pout<< i << ": ";
 
         for (label j = 0; j < m[checkIndex]; j++)
         {
-            Info << setw(12) << K[checkIndex][i][j];
+            Pout<< setw(12) << K[checkIndex][i][j];
         }
 
-        Info << nl;
+        Pout<< nl;
     }
 
-    Info << endl;
+    Pout<< endl;
 }
 
 
@@ -428,14 +600,25 @@ bool dynamicTopoFvMesh::checkTriangulationVolumes
 ) const
 {
     label m = hullVertices.size();
-    scalar tetVol = 0.0;
+    scalar oldTetVol = 0.0, newTetVol = 0.0;
 
     const edge& edgeToCheck = edges_[eIndex];
 
     for (label i = 0; i < (m-2); i++)
     {
         // Compute volume for the upper-half
-        tetVol =
+        newTetVol =
+        (
+            tetPointRef
+            (
+                points_[hullVertices[triangulations[0][i]]],
+                points_[hullVertices[triangulations[1][i]]],
+                points_[hullVertices[triangulations[2][i]]],
+                points_[edgeToCheck[0]]
+            ).mag()
+        );
+
+        oldTetVol =
         (
             tetPointRef
             (
@@ -446,32 +629,37 @@ bool dynamicTopoFvMesh::checkTriangulationVolumes
             ).mag()
         );
 
-        if (tetVol < 0.0)
+        if (oldTetVol < 0.0 || (mag(oldTetVol) < mag(0.1 * newTetVol)))
         {
             if (debug > 2)
             {
-                InfoIn
-                (
-                    "bool dynamicTopoFvMesh::checkTriangulationVolumes\n"
-                    "(\n"
-                    "    const label eIndex,\n"
-                    "    const labelList& hullVertices,\n"
-                    "    const labelListList& triangulations\n"
-                    ") const\n"
-                )
-                    << "Swap sequence leads to negative old-volumes." << nl
-                    << "Edge: " << edgeToCheck << nl
-                    << "using Points: " << nl
+                Pout<< " Swap sequence leads to bad old-volumes." << nl
+                    << " Edge: " << edgeToCheck << nl
+                    << " using Points: " << nl
                     << oldPoints_[hullVertices[triangulations[0][i]]] << nl
                     << oldPoints_[hullVertices[triangulations[1][i]]] << nl
                     << oldPoints_[hullVertices[triangulations[2][i]]] << nl
-                    << oldPoints_[edgeToCheck[0]] << endl;
+                    << oldPoints_[edgeToCheck[0]] << nl
+                    << " Old Volume: " << oldTetVol << nl
+                    << " New Volume: " << newTetVol << nl
+                    << endl;
             }
 
             return true;
         }
 
-        tetVol =
+        newTetVol =
+        (
+            tetPointRef
+            (
+                points_[hullVertices[triangulations[2][i]]],
+                points_[hullVertices[triangulations[1][i]]],
+                points_[hullVertices[triangulations[0][i]]],
+                points_[edgeToCheck[1]]
+            ).mag()
+        );
+
+        oldTetVol =
         (
             tetPointRef
             (
@@ -482,26 +670,20 @@ bool dynamicTopoFvMesh::checkTriangulationVolumes
             ).mag()
         );
 
-        if (tetVol < 0.0)
+        if (oldTetVol < 0.0 || (mag(oldTetVol) < mag(0.1 * newTetVol)))
         {
             if (debug > 2)
             {
-                InfoIn
-                (
-                    "bool dynamicTopoFvMesh::checkTriangulationVolumes\n"
-                    "(\n"
-                    "    const label eIndex,\n"
-                    "    const labelList& hullVertices,\n"
-                    "    const labelListList& triangulations\n"
-                    ") const\n"
-                )
-                    << "Swap sequence leads to negative old-volumes." << nl
-                    << "Edge: " << edgeToCheck << nl
-                    << "using Points: " << nl
+                Pout<< " Swap sequence leads to bad old-volumes." << nl
+                    << " Edge: " << edgeToCheck << nl
+                    << " using Points: " << nl
                     << oldPoints_[hullVertices[triangulations[2][i]]] << nl
                     << oldPoints_[hullVertices[triangulations[1][i]]] << nl
                     << oldPoints_[hullVertices[triangulations[0][i]]] << nl
-                    << oldPoints_[edgeToCheck[1]] << endl;
+                    << oldPoints_[edgeToCheck[1]] << nl
+                    << " Old Volume: " << oldTetVol << nl
+                    << " New Volume: " << newTetVol << nl
+                    << endl;
             }
 
             return true;
@@ -512,6 +694,163 @@ bool dynamicTopoFvMesh::checkTriangulationVolumes
 }
 
 
+// Write out connectivity for an edge
+void dynamicTopoFvMesh::writeEdgeConnectivity
+(
+    const label eIndex
+) const
+{
+    // Write out edge
+    writeVTK("Edge_" + Foam::name(eIndex), eIndex, 1, false, true);
+
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    // Write out edge faces
+    writeVTK
+    (
+        "EdgeFaces_"
+      + Foam::name(eIndex)
+      + '_'
+      + Foam::name(Pstream::myProcNo()),
+        eFaces,
+        2, false, true
+    );
+
+    DynamicList<label> edgeCells(10);
+
+    forAll(eFaces, faceI)
+    {
+        label pIdx = whichPatch(eFaces[faceI]);
+
+        word pName((pIdx < 0) ?	"Internal" : boundaryMesh()[pIdx].name());
+
+        Pout<< " Face: " << eFaces[faceI]
+            << " :: " << faces_[eFaces[faceI]]
+            << " Patch: " << pName
+            << " Proc: " << Pstream::myProcNo() << nl;
+
+        label own = owner_[eFaces[faceI]];
+        label nei = neighbour_[eFaces[faceI]];
+
+        if (findIndex(edgeCells, own) == -1)
+        {
+            edgeCells.append(own);
+        }
+
+        if (nei == -1)
+        {
+            continue;
+        }
+
+        if (findIndex(edgeCells, nei) == -1)
+        {
+            edgeCells.append(nei);
+        }
+    }
+
+    // Write out cells connected to edge
+    writeVTK
+    (
+        "EdgeCells_"
+      + Foam::name(eIndex)
+      + '_'
+      + Foam::name(Pstream::myProcNo()),
+        edgeCells,
+        3, false, true
+    );
+
+    if (twoDMesh_)
+    {
+        return;
+    }
+
+    // Check processors for coupling
+    forAll(procIndices_, pI)
+    {
+        // Fetch reference to subMesh
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        label sI = -1;
+
+        if ((sI = cMap.findSlave(coupleMap::EDGE, eIndex)) == -1)
+        {
+            continue;
+        }
+
+        const edge& slaveEdge = mesh.edges_[sI];
+        const labelList& seFaces = mesh.edgeFaces_[sI];
+
+        edge cE
+        (
+            cMap.findMaster(coupleMap::POINT, slaveEdge[0]),
+            cMap.findMaster(coupleMap::POINT, slaveEdge[1])
+        );
+
+        Pout<< " >> Edge: " << sI << "::" << slaveEdge
+            << " mapped: " << cE << nl;
+
+        mesh.writeVTK
+        (
+            "EdgeFaces_"
+          + Foam::name(eIndex)
+          + '_'
+          + Foam::name(procIndices_[pI]),
+            seFaces,
+            2, false, true
+        );
+
+        // Clear existing list
+        edgeCells.clear();
+
+        forAll(seFaces, faceI)
+        {
+            label pIdx = mesh.whichPatch(seFaces[faceI]);
+
+            word pName
+            (
+                (pIdx < 0) ?
+                "Internal" :
+                mesh.boundaryMesh()[pIdx].name()
+            );
+
+            Pout<< " Face: " << seFaces[faceI]
+                << " :: " << mesh.faces_[seFaces[faceI]]
+                << " Patch: " << pName
+                << " Proc: " << procIndices_[pI] << nl;
+
+            label own = mesh.owner_[seFaces[faceI]];
+            label nei = mesh.neighbour_[seFaces[faceI]];
+
+            if (findIndex(edgeCells, own) == -1)
+            {
+                edgeCells.append(own);
+            }
+
+            if (nei == -1)
+            {
+                continue;
+            }
+
+            if (findIndex(edgeCells, nei) == -1)
+            {
+                edgeCells.append(nei);
+            }
+        }
+
+        mesh.writeVTK
+        (
+            "EdgeCells_"
+          + Foam::name(eIndex)
+          + '_'
+          + Foam::name(procIndices_[pI]),
+            edgeCells,
+            3, false, true
+        );
+    }
+}
+
+
 // Output an entity as a VTK file
 void dynamicTopoFvMesh::writeVTK
 (
@@ -545,9 +884,105 @@ void dynamicTopoFvMesh::writeVTK
     const labelList& cList,
     const label primitiveType,
     const bool useOldConnectivity,
-    const bool useOldPoints
+    const bool useOldPoints,
+    const UList<scalar>& scalField,
+    const UList<label>& lablField
 ) const
 {
+    // Check if spatial bounding box has been specified
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+    labelList entityList;
+
+    if (meshSubDict.found("spatialDebug") && !useOldConnectivity)
+    {
+        // Read the bounding box
+        boundBox bb
+        (
+            meshSubDict.subDict("spatialDebug").lookup("debugBoundBox")
+        );
+
+        DynamicList<label> cSubList(10);
+
+        forAll(cList, cellI)
+        {
+            label index = cList[cellI];
+
+            if (index < 0)
+            {
+                continue;
+            }
+
+            point containPoint(vector::zero);
+
+            switch (primitiveType)
+            {
+                // Are we looking at points?
+                case 0:
+                {
+                    containPoint = points_[index];
+                    break;
+                }
+
+                // Are we looking at edges?
+                case 1:
+                {
+                    containPoint = edges_[index].centre(points_);
+                    break;
+                }
+
+                // Are we looking at faces?
+                case 2:
+                {
+                    containPoint = faces_[index].centre(points_);
+                    break;
+                }
+
+                // Are we looking at cells?
+                case 3:
+                {
+                    scalar volume = 0.0;
+
+                    // Compute centre
+                    meshOps::cellCentreAndVolume
+                    (
+                        index,
+                        points_,
+                        faces_,
+                        cells_,
+                        owner_,
+                        containPoint,
+                        volume
+                    );
+
+                    break;
+                }
+            }
+
+            // Is the point of interest?
+            if (bb.contains(containPoint))
+            {
+                cSubList.append(index);
+            }
+        }
+
+        // If nothing is present, don't write out anything
+        if (cSubList.empty())
+        {
+            return;
+        }
+        else
+        {
+            // Take over contents
+            entityList = cSubList;
+        }
+    }
+    else
+    {
+        // Conventional output
+        entityList = cList;
+    }
+
     if (useOldPoints)
     {
         if (useOldConnectivity)
@@ -557,13 +992,15 @@ void dynamicTopoFvMesh::writeVTK
             (
                 (*this),
                 name,
-                cList,
+                entityList,
                 primitiveType,
                 polyMesh::points(),
                 polyMesh::edges(),
                 polyMesh::faces(),
                 polyMesh::cells(),
-                polyMesh::faceOwner()
+                polyMesh::faceOwner(),
+                scalField,
+                lablField
             );
         }
         else
@@ -572,13 +1009,15 @@ void dynamicTopoFvMesh::writeVTK
             (
                 (*this),
                 name,
-                cList,
+                entityList,
                 primitiveType,
                 oldPoints_,
                 edges_,
                 faces_,
                 cells_,
-                owner_
+                owner_,
+                scalField,
+                lablField
             );
         }
     }
@@ -588,13 +1027,15 @@ void dynamicTopoFvMesh::writeVTK
         (
             (*this),
             name,
-            cList,
+            entityList,
             primitiveType,
             points_,
             edges_,
             faces_,
             cells_,
-            owner_
+            owner_,
+            scalField,
+            lablField
         );
     }
 }
@@ -603,8 +1044,8 @@ void dynamicTopoFvMesh::writeVTK
 // Return the status report interval
 scalar dynamicTopoFvMesh::reportInterval() const
 {
-    // Default to 3 seconds
-    scalar interval = 3.0;
+    // Default to 1 second
+    scalar interval = 1.0;
 
     const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
 
@@ -636,7 +1077,7 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
     );
 
     // Check face-label ranges
-    Info << "Checking index ranges...";
+    Pout<< "Checking index ranges...";
 
     forAll(edges_, edgeI)
     {
@@ -653,31 +1094,31 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
             curEdge[1] < 0 || curEdge[1] > (points_.size()-1)
         )
         {
-            Pout << "Edge " << edgeI
-                 << " contains vertex labels out of range: "
-                 << curEdge
-                 << " Max point index = " << (points_.size()-1) << endl;
+            Pout<< "Edge " << edgeI
+                << " contains vertex labels out of range: "
+                << curEdge
+                << " Max point index = " << (points_.size()-1) << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Edge-point connectivity is inconsistent."
-                 << endl;
+                << nl << "Edge-point connectivity is inconsistent."
+                << endl;
         }
 
         // Check for unique point-labels
         if (curEdge[0] == curEdge[1])
         {
-            Pout << "Edge " << edgeI
-                 << " contains identical vertex labels: "
-                 << curEdge
-                 << endl;
+            Pout<< "Edge " << edgeI
+                << " contains identical vertex labels: "
+                << curEdge
+                << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Edge-point connectivity is inconsistent."
-                 << endl;
+                << nl << "Edge-point connectivity is inconsistent."
+                << endl;
         }
     }
 
@@ -695,16 +1136,16 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if (min(curFace) < 0 || max(curFace) > (points_.size()-1))
         {
-            Pout << "Face " << faceI
-                 << " contains vertex labels out of range: "
-                 << curFace
-                 << " Max point index = " << (points_.size()-1) << endl;
+            Pout<< "Face " << faceI
+                << " contains vertex labels out of range: "
+                << curFace
+                << " Max point index = " << (points_.size()-1) << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Face-point connectivity is inconsistent."
-                 << endl;
+                << nl << "Face-point connectivity is inconsistent."
+                << endl;
         }
 
         // Check for unique point-labels
@@ -716,16 +1157,16 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (!inserted)
             {
-                Pout << "Face " << faceI
-                     << " contains identical vertex labels: "
-                     << curFace
-                     << endl;
+                Pout<< "Face " << faceI
+                    << " contains identical vertex labels: "
+                    << curFace
+                    << endl;
 
                 nFailedChecks++;
 
                 ConnectivityWarning()
-                     << nl << "Face-point connectivity is inconsistent."
-                     << endl;
+                    << nl << "Face-point connectivity is inconsistent."
+                    << endl;
             }
         }
 
@@ -754,17 +1195,17 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (nCommon != 1)
             {
-                Pout << "Cells: " << nl
-                     << '\t' << owner_[faceI] << ":: " << ownCell << nl
-                     << '\t' << neighbour_[faceI] << " :: " << neiCell << nl
-                     << " share multiple faces. "
-                     << endl;
+                Pout<< "Cells: " << nl
+                    << '\t' << owner_[faceI] << ":: " << ownCell << nl
+                    << '\t' << neighbour_[faceI] << " :: " << neiCell << nl
+                    << " share multiple faces. "
+                    << endl;
 
                 nFailedChecks++;
 
                 ConnectivityWarning()
-                     << nl << "Cell-Face connectivity is inconsistent."
-                     << endl;
+                    << nl << "Cell-Face connectivity is inconsistent."
+                    << endl;
             }
         }
     }
@@ -783,16 +1224,15 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if (min(curCell) < 0 || max(curCell) > (faces_.size()-1))
         {
-            Pout << "Cell " << cellI
-                 << " contains vertex labels out of range: "
-                 << curCell
-                 << " Max point index = " << (faces_.size()-1) << endl;
+            Pout<< "Cell " << cellI
+                << " contains face labels out of range: " << curCell
+                << " Max face index = " << (faces_.size()-1) << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Cell-Face connectivity is inconsistent."
-                 << endl;
+                << nl << "Cell-Face connectivity is inconsistent."
+                << endl;
         }
 
         // Check for unique face-labels
@@ -804,16 +1244,16 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (!inserted)
             {
-                Pout << "Cell " << cellI
-                     << " contains identical face labels: "
-                     << curCell
-                     << endl;
+                Pout<< "Cell " << cellI
+                    << " contains identical face labels: "
+                    << curCell
+                    << endl;
 
                 nFailedChecks++;
 
                 ConnectivityWarning()
-                     << nl << "Cell-Face connectivity is inconsistent."
-                     << endl;
+                    << nl << "Cell-Face connectivity is inconsistent."
+                    << endl;
             }
 
             // Count cells per face
@@ -821,79 +1261,108 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
         }
     }
 
-    Info << "Done." << endl;
+    Pout<< "Done." << endl;
 
-    Info << "Checking face-cell connectivity...";
+    Pout<< "Checking face-cell connectivity...";
 
     forAll(nCellsPerFace, faceI)
     {
+        // This might be a deleted face
+        if (faceI < nOldFaces_)
+        {
+            if (reverseFaceMap_[faceI] == -1)
+            {
+                continue;
+            }
+        }
+        else
+        if (deletedFaces_.found(faceI))
+        {
+            continue;
+        }
+
+        // Determine patch
+        label uPatch = whichPatch(faceI);
+
         if (nCellsPerFace[faceI] == 0)
         {
-            // This might be a deleted face
-            if (faceI < nOldFaces_)
-            {
-                if (reverseFaceMap_[faceI] == -1)
-                {
-                    continue;
-                }
-            }
-            else
-            {
-                if (deletedFaces_.found(faceI))
-                {
-                    continue;
-                }
-            }
-
             // Looks like this is really an unused face.
-            Pout << "Face " << faceI
-                 << " :: " << faces_[faceI]
-                 << " is unused. "
-                 << endl;
+            Pout<< "Face " << faceI << " :: " << faces_[faceI]
+                << " is unused. Patch: "
+                << (uPatch > -1 ? boundaryMesh()[uPatch].name() : "Internal")
+                << nl << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Cell-Face connectivity is inconsistent."
-                 << endl;
+                << nl << "Cell-Face connectivity is inconsistent."
+                << endl;
         }
         else
-        if (nCellsPerFace[faceI] != 2 && whichPatch(faceI) == -1)
+        if (nCellsPerFace[faceI] != 2 && uPatch == -1)
         {
             // Internal face is not shared by exactly two cells
-            Pout << "Internal Face " << faceI
-                 << " :: " << faces_[faceI]
-                 << " is multiply connected." << nl
-                 << " nCellsPerFace: " << nCellsPerFace[faceI]
-                 << endl;
+            Pout<< "Internal Face " << faceI
+                << " :: " << faces_[faceI]
+                << " Owner: " << owner_[faceI]
+                << " Neighbour: " << neighbour_[faceI]
+                << " is multiply connected." << nl
+                << " nCellsPerFace: " << nCellsPerFace[faceI] << nl
+                << " Patch: Internal" << nl
+                << endl;
+
+            // Loop through cells and find another instance
+            forAll(cells_, cellI)
+            {
+                if (findIndex(cells_[cellI], faceI) > -1)
+                {
+                    Pout<< "  Cell: " << cellI
+                        << "  :: " << cells_[cellI]
+                        << endl;
+                }
+            }
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Cell-Face connectivity is inconsistent."
-                 << endl;
+                << nl << "Cell-Face connectivity is inconsistent."
+                << endl;
         }
         else
-        if (nCellsPerFace[faceI] != 1 && whichPatch(faceI) > -1)
+        if (nCellsPerFace[faceI] != 1 && uPatch > -1)
         {
             // Boundary face is not shared by exactly one cell
-            Pout << "Boundary Face " << faceI
-                 << " :: " << faces_[faceI]
-                 << " is multiply connected." << nl
-                 << " nCellsPerFace: " << nCellsPerFace[faceI]
-                 << endl;
+            Pout<< "Boundary Face " << faceI
+                << " :: " << faces_[faceI]
+                << " Owner: " << owner_[faceI]
+                << " Neighbour: " << neighbour_[faceI]
+                << " is multiply connected." << nl
+                << " nCellsPerFace: " << nCellsPerFace[faceI] << nl
+                << " Patch: " << boundaryMesh()[uPatch].name() << nl
+                << endl;
+
+            // Loop through cells and find another instance
+            forAll(cells_, cellI)
+            {
+                if (findIndex(cells_[cellI], faceI) > -1)
+                {
+                    Pout<< "  Cell: " << cellI
+                        << "  :: " << cells_[cellI]
+                        << endl;
+                }
+            }
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Cell-Face connectivity is inconsistent."
-                 << endl;
+                << nl << "Cell-Face connectivity is inconsistent."
+                << endl;
         }
     }
 
-    Info << "Done." << endl;
+    Pout<< "Done." << endl;
 
-    Info << "Checking for unused points...";
+    Pout<< "Checking for unused points...";
 
     forAll(nPointFaces, pointI)
     {
@@ -916,19 +1385,20 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
             }
 
             // Looks like this is really an unused point.
-            Pout << "Point " << pointI << " is unused. " << endl;
+            Pout<< nl << nl << "Point " << pointI
+                << " is unused. " << endl;
 
             nFailedChecks++;
 
             ConnectivityWarning()
-                 << nl << "Point-Face connectivity is inconsistent."
-                 << endl;
+                << nl << "Point-Face connectivity is inconsistent."
+                << endl;
         }
     }
 
-    Info << "Done." << endl;
+    Pout<< "Done." << endl;
 
-    Info << "Checking edge-face connectivity...";
+    Pout<< "Checking edge-face connectivity...";
 
     label allEdges = edges_.size();
     labelList nEdgeFaces(allEdges, 0);
@@ -964,23 +1434,24 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (!found)
             {
-                Pout << nl << nl << "Edge: " << faceEdges[edgeI]
-                     << ": " << edgeToCheck << nl
-                     << "was not found in face: " << faceI
-                     << ": " << faces_[faceI] << nl
-                     << "faceEdges: " << faceEdges
-                     << endl;
+                Pout<< nl << nl << "Edge: " << faceEdges[edgeI]
+                    << ": " << edgeToCheck << nl
+                    << "was not found in face: " << faceI
+                    << ": " << faces_[faceI] << nl
+                    << "faceEdges: " << faceEdges
+                    << endl;
 
                 nFailedChecks++;
 
                 ConnectivityWarning()
-                     << nl << "Edge-Face connectivity is inconsistent."
-                     << endl;
+                    << nl << "Edge-Face connectivity is inconsistent."
+                    << endl;
             }
         }
     }
 
     label nInternalEdges = 0;
+    DynamicList<label> bPatchIDs(10);
     labelList patchInfo(boundaryMesh().size(), 0);
 
     forAll(edgeFaces_, edgeI)
@@ -994,8 +1465,11 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if (edgeFaces.size() != nEdgeFaces[edgeI])
         {
-            Pout << nl << nl << "Edge: " << edgeI
-                 << ": edgeFaces: " << edgeFaces << endl;
+            Pout<< nl << nl << "Edge: " << edgeI << ": " << edges_[edgeI]
+                << ": edgeFaces: " << edgeFaces
+                << nl << UIndirectList<face>(faces_, edgeFaces)
+                << nl << " Expected nFaces: " << nEdgeFaces[edgeI]
+                << endl;
 
             nFailedChecks++;
 
@@ -1005,18 +1479,23 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
         }
 
         label nBF = 0;
+        bPatchIDs.clear();
 
         // Check if this edge belongs to faceEdges for each face
         forAll(edgeFaces, faceI)
         {
-            if (findIndex(faceEdges_[edgeFaces[faceI]], edgeI) == -1)
+            const labelList& faceEdges = faceEdges_[edgeFaces[faceI]];
+
+            if (findIndex(faceEdges, edgeI) == -1)
             {
-                Pout << nl << nl << "Edge: " << edgeI << ": " << edges_[edgeI]
-                     << ", edgeFaces: " << edgeFaces << nl
-                     << "was not found in faceEdges of face: "
-                     << edgeFaces[faceI] << ": " << faces_[edgeFaces[faceI]]
-                     << nl << "faceEdges: " << faceEdges_[edgeFaces[faceI]]
-                     << endl;
+                Pout<< nl << nl << "Edge: " << edgeI << ": " << edges_[edgeI]
+                    << ", edgeFaces: " << edgeFaces
+                    << nl << UIndirectList<face>(faces_, edgeFaces)
+                    << "was not found in faceEdges of face: "
+                    << edgeFaces[faceI] << ": " << faces_[edgeFaces[faceI]]
+                    << nl << "faceEdges: " << faceEdges
+                    << nl << UIndirectList<edge>(edges_, faceEdges)
+                    << endl;
 
                 nFailedChecks++;
 
@@ -1027,6 +1506,9 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (neighbour_[edgeFaces[faceI]] == -1)
             {
+                // Add to list of patch IDs
+                bPatchIDs.append(whichPatch(edgeFaces[faceI]));
+
                 nBF++;
             }
         }
@@ -1038,11 +1520,11 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
             // Check if this edge is actually internal.
             if (whichEdgePatch(edgeI) >= 0)
             {
-                Pout << "Edge: " << edgeI
-                     << ": " << edges_[edgeI] << " is internal, "
-                     << " but patch is specified as: "
-                     << whichEdgePatch(edgeI)
-                     << endl;
+                Pout<< "Edge: " << edgeI
+                    << ": " << edges_[edgeI] << " is internal, "
+                    << " but patch is specified as: "
+                    << whichEdgePatch(edgeI)
+                    << endl;
 
                 nFailedChecks++;
             }
@@ -1054,10 +1536,10 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
             // Check if this edge is actually on a boundary.
             if (patchID < 0)
             {
-                Pout << "Edge: " << edgeI
-                     << ": " << edges_[edgeI]
-                     << " is on a boundary, but patch is specified as: "
-                     << patchID << endl;
+                Pout<< "Edge: " << edgeI
+                    << ": " << edges_[edgeI]
+                    << " is on a boundary, but patch is specified as: "
+                    << patchID << endl;
 
                 nFailedChecks++;
             }
@@ -1066,14 +1548,49 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
                 patchInfo[patchID]++;
             }
 
+            bool failedManifoldCheck = false;
+
             if (nBF > 2)
             {
-                Pout << "Edge: " << edgeI
-                     << ": " << edges_[edgeI]
-                     << " has " << nBF
-                     << " boundary faces connected to it." << nl
-                     << " Pinched manifolds are not allowed."
-                     << endl;
+                if (Pstream::parRun())
+                {
+                    // Pinched manifolds should be allowed in parallel
+                    failedManifoldCheck = false;
+                }
+                else
+                {
+                    failedManifoldCheck = true;
+                }
+            }
+
+            if (failedManifoldCheck)
+            {
+                // Write out for post-processing
+                forAll(bPatchIDs, faceI)
+                {
+                    if (bPatchIDs[faceI] == -1)
+                    {
+                        Pout<< " Edge: " << edgeI
+                            << " Face Patch: Internal" << nl;
+                    }
+                    else
+                    {
+                        Pout<< " Edge: " << edgeI
+                            << " Face Patch: "
+                            << boundaryMesh()[bPatchIDs[faceI]].name() << nl;
+                    }
+                }
+
+                Pout<< endl;
+
+                writeVTK("pinched_" + Foam::name(edgeI), edgeFaces, 2);
+
+                Pout<< "Edge: " << edgeI
+                    << ": " << edges_[edgeI]
+                    << " has " << nBF
+                    << " boundary faces connected to it." << nl
+                    << " Pinched manifolds are not allowed."
+                    << endl;
 
                 nFailedChecks++;
             }
@@ -1082,9 +1599,9 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
     if (nInternalEdges != nInternalEdges_)
     {
-        Pout << nl << "Internal edge-count is inconsistent." << nl
-             << " Counted internal edges: " << nInternalEdges
-             << " Actual count: " << nInternalEdges_ << endl;
+        Pout<< nl << "Internal edge-count is inconsistent." << nl
+            << " Counted internal edges: " << nInternalEdges
+            << " Actual count: " << nInternalEdges_ << endl;
 
         nFailedChecks++;
     }
@@ -1093,10 +1610,10 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
     {
         if (patchInfo[patchI] != edgePatchSizes_[patchI])
         {
-            Pout << "Patch-count is inconsistent." << nl
-                 << " Patch: " << patchI
-                 << " Counted edges: " << patchInfo[patchI]
-                 << " Actual count: " << edgePatchSizes_[patchI] << endl;
+            Pout<< "Patch-count is inconsistent." << nl
+                << " Patch: " << patchI
+                << " Counted edges: " << patchInfo[patchI]
+                << " Actual count: " << edgePatchSizes_[patchI] << endl;
 
             nFailedChecks++;
         }
@@ -1122,31 +1639,60 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if ((patch < 0) && (nBF > 0))
         {
-            Pout << nl << nl << "Edge: " << key
-                 << ", edgeFaces: " << edgeFaces
-                 << " is internal, but contains boundary faces."
-                 << endl;
+            Pout<< nl << nl << "Edge: " << key
+                << "::" << edges_[key]
+                << ", edgeFaces: " << edgeFaces
+                << " is internal, but contains boundary faces."
+                << endl;
 
             nFailedChecks++;
         }
 
         if ((patch >= 0) && (nBF != 2))
         {
-            Pout << nl << nl << "Edge: " << key
-                 << ", edgeFaces: " << edgeFaces
-                 << " is on a boundary patch, but doesn't contain"
-                 << " two boundary faces."
-                 << endl;
+            if (!Pstream::parRun())
+            {
+                Pout<< nl << nl << "Edge: " << key
+                    << "::" << edges_[key]
+                    << ", edgeFaces: " << edgeFaces
+                    << " is on a boundary patch, but doesn't contain"
+                    << " two boundary faces."
+                    << endl;
 
-            nFailedChecks++;
+                nFailedChecks++;
+            }
         }
     }
 
-    Info << "Done." << endl;
+    Pout<< "Done." << endl;
+
+    // Check coupled-patch sizes
+    forAll(patchCoupling_, patchI)
+    {
+        if (patchCoupling_(patchI))
+        {
+            const coupleMap& cMap = patchCoupling_[patchI].map();
+
+            label mSize = patchSizes_[cMap.masterIndex()];
+            label sSize = patchSizes_[cMap.slaveIndex()];
+
+            if (mSize != sSize)
+            {
+                Pout<< "Coupled patch-count is inconsistent." << nl
+                    << " Master Patch: " << cMap.masterIndex()
+                    << " Count: " << mSize << nl
+                    << " Slave Patch: " << cMap.slaveIndex()
+                    << " Count: " << sSize
+                    << endl;
+
+                nFailedChecks++;
+            }
+        }
+    }
 
     if (!twoDMesh_)
     {
-        Info << "Checking point-edge connectivity...";
+        Pout<< "Checking point-edge connectivity...";
 
         label allPoints = points_.size();
         List<labelHashSet> hlPointEdges(allPoints);
@@ -1173,10 +1719,10 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
             {
                 if (!hlPointEdges[pointI].found(pointEdges[edgeI]))
                 {
-                    Pout << nl << nl << "Point: " << pointI << nl
-                         << "pointEdges: " << pointEdges << nl
-                         << "hlPointEdges: " << hlPointEdges[pointI]
-                         << endl;
+                    Pout<< nl << nl << "Point: " << pointI << nl
+                        << "pointEdges: " << pointEdges << nl
+                        << "hlPointEdges: " << hlPointEdges[pointI]
+                        << endl;
 
                     nFailedChecks++;
 
@@ -1193,104 +1739,24 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
                 pointEdges.size() == 1
             )
             {
-                Pout << nl << nl << "Point: " << pointI << nl
-                     << "pointEdges: " << pointEdges << nl
-                     << "hlPointEdges: " << hlPointEdges[pointI]
-                     << endl;
+                Pout<< nl << nl << "Point: " << pointI << nl
+                    << "pointEdges: " << pointEdges << nl
+                    << "hlPointEdges: " << hlPointEdges[pointI]
+                    << endl;
 
                 nFailedChecks++;
 
                 ConnectivityWarning()
-                    << "Size inconsistency."
+                    << nl << "Size inconsistency."
                     << nl << "Point-Edge connectivity is inconsistent."
                     << endl;
             }
         }
 
-        Info << "Done." << endl;
-
-        Info << "Checking edge-points connectivity...";
-
-        label otherPoint = -1, nextPoint = -1;
-
-        forAll(edgePoints_, edgeI)
-        {
-            // Do a preliminary size check
-            const labelList& edgePoints = edgePoints_[edgeI];
-            const labelList& edgeFaces = edgeFaces_[edgeI];
-
-            if (edgeFaces.empty())
-            {
-                continue;
-            }
-
-            if (edgePoints.size() != edgeFaces.size())
-            {
-                Pout << nl << nl
-                     << "Edge: " << edgeI
-                     << " " << edges_[edgeI] << endl;
-
-                Pout << "edgeFaces: " << edgeFaces << endl;
-                forAll(edgeFaces, faceI)
-                {
-                    Info << edgeFaces[faceI] << ": "
-                         << faces_[edgeFaces[faceI]]
-                         << endl;
-                }
-
-                Pout << "edgePoints: " << edgePoints << endl;
-
-                nFailedChecks++;
-
-                ConnectivityWarning()
-                    << nl << "Edge-Points connectivity is inconsistent."
-                    << endl;
-            }
-
-            // Now check to see that both lists are consistent.
-            const edge& edgeToCheck = edges_[edgeI];
-
-            forAll(edgeFaces, faceI)
-            {
-                const face& faceToCheck = faces_[edgeFaces[faceI]];
-
-                meshOps::findIsolatedPoint
-                (
-                    faceToCheck,
-                    edgeToCheck,
-                    otherPoint,
-                    nextPoint
-                );
-
-                if (findIndex(edgePoints, otherPoint) == -1)
-                {
-                    Pout << nl << nl
-                         << "Edge: " << edgeI
-                         << " " << edges_[edgeI] << endl;
-
-                    Pout << "edgeFaces: " << edgeFaces << endl;
-                    forAll(edgeFaces, faceI)
-                    {
-                        Info << edgeFaces[faceI] << ": "
-                             << faces_[edgeFaces[faceI]]
-                             << endl;
-                    }
-
-                    Pout << "edgePoints: " << edgePoints << endl;
-
-                    nFailedChecks++;
-
-                    ConnectivityWarning()
-                        << nl << "Edge-Points connectivity is inconsistent."
-                        << endl;
-                }
-            }
-        }
-
-        Info << "Done." << endl;
+        Pout<< "Done." << endl;
     }
 
-    Info << "Checking cell-point connectivity...";
+    Pout<< "Checking cell-point connectivity...";
 
     // Loop through all cells and construct cell-to-node
     label cIndex = 0;
@@ -1339,33 +1805,43 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
     // Preliminary check for size
     forAll(cellToNode, cellI)
     {
+        // Check for hexahedral cells
+        if
+        (
+            (cellToNode[cellI].size() == 8) &&
+            (cells_[cellIndex[cellI]].size() == 6)
+        )
+        {
+            continue;
+        }
+
         if
         (
             (cellToNode[cellI].size() != 6 && twoDMesh_) ||
             (cellToNode[cellI].size() != 4 && !twoDMesh_)
         )
         {
-            Pout << nl << "Warning: Cell: "
-                 << cellIndex[cellI] << " is inconsistent. "
-                 << endl;
+            Pout<< nl << "Warning: Cell: "
+                << cellIndex[cellI] << " is inconsistent. "
+                << endl;
 
             const cell& failedCell = cells_[cellIndex[cellI]];
 
-            Info << "Cell faces: " << failedCell << endl;
+            Pout<< "Cell faces: " << failedCell << endl;
 
             forAll(failedCell, faceI)
             {
-                Info << "\tFace: " << failedCell[faceI]
-                     << " :: " << faces_[failedCell[faceI]]
-                     << endl;
+                Pout<< "\tFace: " << failedCell[faceI]
+                    << " :: " << faces_[failedCell[faceI]]
+                    << endl;
 
                 const labelList& fEdges = faceEdges_[failedCell[faceI]];
 
                 forAll(fEdges, edgeI)
                 {
-                    Info << "\t\tEdge: " << fEdges[edgeI]
-                         << " :: " << edges_[fEdges[edgeI]]
-                         << endl;
+                    Pout<< "\t\tEdge: " << fEdges[edgeI]
+                        << " :: " << edges_[fEdges[edgeI]]
+                        << endl;
                 }
             }
 
@@ -1373,9 +1849,7 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
         }
     }
 
-    Info << "Done." << endl;
-
-    reduce(nFailedChecks, orOp<bool>());
+    Pout<< "Done." << endl;
 
     if (nFailedChecks)
     {
@@ -1534,13 +2008,15 @@ bool dynamicTopoFvMesh::checkBisection
 }
 
 
-// Utility method to check whether the cell given by 'cellIndex' will yield
-// a valid cell when 'pointIndex' is moved to 'newPoint'.
+// Utility method to check whether the faces in triFaces will yield
+// valid triangles when 'pointIndex' is moved to 'newPoint'.
 //  - The routine performs metric-based checks.
-//  - Returns 'true' if the collapse in NOT feasible, and
-//    makes entries in cellsChecked to avoid repetitive checks.
+//  - Returns 'true' if the collapse in NOT feasible.
+//  - Does not reference member data, because this function
+//    is also used on subMeshes
 bool dynamicTopoFvMesh::checkCollapse
 (
+    const dynamicTopoFvMesh& mesh,
     const labelList& triFaces,
     const FixedList<label,2>& c0BdyIndex,
     const FixedList<label,2>& c1BdyIndex,
@@ -1550,7 +2026,7 @@ bool dynamicTopoFvMesh::checkCollapse
     scalar& collapseQuality,
     const bool checkNeighbour,
     bool forceOp
-) const
+)
 {
     // Reset input
     collapseQuality = GREAT;
@@ -1579,7 +2055,7 @@ bool dynamicTopoFvMesh::checkCollapse
             }
         }
 
-        const face& checkFace = faces_[triFaces[indexI]];
+        const face& checkFace = mesh.faces_[triFaces[indexI]];
 
         // Configure a triangle face
         FixedList<point, 3> tFNew(vector::zero);
@@ -1588,8 +2064,8 @@ bool dynamicTopoFvMesh::checkCollapse
         // Make necessary replacements
         forAll(checkFace, pointI)
         {
-            tFNew[pointI] = points_[checkFace[pointI]];
-            tFOld[pointI] = oldPoints_[checkFace[pointI]];
+            tFNew[pointI] = mesh.points_[checkFace[pointI]];
+            tFOld[pointI] = mesh.oldPoints_[checkFace[pointI]];
 
             if (checkFace[pointI] == pointIndex[0])
             {
@@ -1643,20 +2119,44 @@ bool dynamicTopoFvMesh::checkCollapse
     }
 
     // Final quality check
-    if (collapseQuality < sliverThreshold_ && !forceOp)
+    if (collapseQuality < mesh.sliverThreshold_ && !forceOp)
     {
+        if (debug > 3)
+        {
+            Pout<< " * * * 2D checkCollapse * * * " << nl
+                << " collapseQuality: " << collapseQuality
+                << " below threshold: " << mesh.sliverThreshold_
+                << endl;
+        }
+
         return true;
     }
 
     // Negative quality is a no-no
     if (collapseQuality < 0.0)
     {
+        if (forceOp)
+        {
+            Pout<< " * * * 2D checkCollapse * * * " << nl
+                << " Negative collapseQuality: " << collapseQuality << nl
+                << " Operation cannot be forced."
+                << endl;
+        }
+
         return true;
     }
 
     // Negative old-area is also a no-no
     if (minArea < 0.0)
     {
+        if (forceOp)
+        {
+            Pout<< " * * * 2D checkCollapse * * * " << nl
+                << " minArea: " << minArea << nl
+                << " Operation cannot be forced."
+                << endl;
+        }
+
         return true;
     }
 
@@ -1676,13 +2176,13 @@ bool dynamicTopoFvMesh::checkCollapse
     const point& oldPoint,
     const label pointIndex,
     const label cellIndex,
-    labelHashSet& cellsChecked,
+    DynamicList<label>& cellsChecked,
     scalar& collapseQuality,
     bool forceOp
 ) const
 {
     label faceIndex = -1;
-    scalar cQuality = 0.0, oldVolume = 0.0;
+    scalar cQuality = 0.0, oldVolume = 0.0, newVolume = 0.0;
     const cell& cellToCheck = cells_[cellIndex];
 
     // Look for a face that doesn't contain 'pointIndex'
@@ -1713,6 +2213,17 @@ bool dynamicTopoFvMesh::checkCollapse
             )
         );
 
+        newVolume =
+        (
+            tetPointRef
+            (
+                points_[faceToCheck[2]],
+                points_[faceToCheck[1]],
+                points_[faceToCheck[0]],
+                newPoint
+            ).mag()
+        );
+
         oldVolume =
         (
             tetPointRef
@@ -1737,6 +2248,17 @@ bool dynamicTopoFvMesh::checkCollapse
             )
         );
 
+        newVolume =
+        (
+            tetPointRef
+            (
+                points_[faceToCheck[0]],
+                points_[faceToCheck[1]],
+                points_[faceToCheck[2]],
+                newPoint
+            ).mag()
+        );
+
         oldVolume =
         (
             tetPointRef
@@ -1752,22 +2274,9 @@ bool dynamicTopoFvMesh::checkCollapse
     // Final quality check
     if (cQuality < sliverThreshold_ && !forceOp)
     {
-        if (debug > 3)
+        if (debug > 4)
         {
-            InfoIn
-            (
-                "\n\n"
-                "bool dynamicTopoFvMesh::checkCollapse\n"
-                "(\n"
-                "    const point& newPoint,\n"
-                "    const point& oldPoint,\n"
-                "    const label pointIndex,\n"
-                "    const label cellIndex,\n"
-                "    labelHashSet& cellsChecked,\n"
-                "    scalar& collapseQuality,\n"
-                "    bool forceOp\n"
-                ") const\n"
-            )
+            Pout<< " * * * 3D checkCollapse * * * " << nl
                 << "\nCollapsing cell: " << cellIndex
                 << " containing points:\n"
                 << faceToCheck[0] << "," << faceToCheck[1] << ","
@@ -1787,20 +2296,7 @@ bool dynamicTopoFvMesh::checkCollapse
     {
         if (forceOp)
         {
-            InfoIn
-            (
-                "\n\n"
-                "bool dynamicTopoFvMesh::checkCollapse\n"
-                "(\n"
-                "    const point& newPoint,\n"
-                "    const point& oldPoint,\n"
-                "    const label pointIndex,\n"
-                "    const label cellIndex,\n"
-                "    labelHashSet& cellsChecked,\n"
-                "    scalar& collapseQuality,\n"
-                "    bool forceOp\n"
-                ") const\n"
-            )
+            Pout<< " * * * 3D checkCollapse * * * " << nl
                 << "\nCollapsing cell: " << cellIndex
                 << " containing points:\n"
                 << faceToCheck[0] << "," << faceToCheck[1] << ","
@@ -1817,24 +2313,11 @@ bool dynamicTopoFvMesh::checkCollapse
     }
 
     // Negative old-volume is also a no-no
-    if (oldVolume < 0.0)
+    if (oldVolume < 0.0 || (mag(oldVolume) < mag(0.1 * newVolume)))
     {
         if (forceOp)
         {
-            InfoIn
-            (
-                "\n\n"
-                "bool dynamicTopoFvMesh::checkCollapse\n"
-                "(\n"
-                "    const point& newPoint,\n"
-                "    const point& oldPoint,\n"
-                "    const label pointIndex,\n"
-                "    const label cellIndex,\n"
-                "    labelHashSet& cellsChecked,\n"
-                "    scalar& collapseQuality,\n"
-                "    bool forceOp\n"
-                ") const\n"
-            )
+            Pout<< " * * * 3D checkCollapse * * * " << nl
                 << "\nCollapsing cell: " << cellIndex
                 << " containing points:\n"
                 << faceToCheck[0] << "," << faceToCheck[1] << ","
@@ -1843,6 +2326,7 @@ bool dynamicTopoFvMesh::checkCollapse
                 << ", when " << pointIndex
                 << " is moved to location: " << nl
                 << oldPoint << nl
+                << "newVolume: " << newVolume << nl
                 << "Operation cannot be forced."
                 << endl;
         }
@@ -1851,7 +2335,7 @@ bool dynamicTopoFvMesh::checkCollapse
     }
 
     // No problems, so a collapse is feasible
-    cellsChecked.insert(cellIndex);
+    cellsChecked.append(cellIndex);
 
     // Update input quality
     collapseQuality = Foam::min(collapseQuality, cQuality);
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
new file mode 100644
index 000000000..87275ddd7
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
@@ -0,0 +1,10088 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    Functions specific to coupled connectivity
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicTopoFvMesh.H"
+
+#include "Time.H"
+#include "eMesh.H"
+#include "triFace.H"
+#include "volFields.H"
+#include "changeMap.H"
+#include "topoMapper.H"
+#include "coupledInfo.H"
+#include "matchPoints.H"
+#include "SortableList.H"
+#include "motionSolver.H"
+#include "surfaceFields.H"
+#include "globalMeshData.H"
+#include "cyclicPolyPatch.H"
+#include "fvMeshDistribute.H"
+#include "faceSetAlgorithm.H"
+#include "cellSetAlgorithm.H"
+#include "coordinateSystem.H"
+#include "processorPolyPatch.H"
+#include "decompositionMethod.H"
+#include "mapDistributePolyMesh.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(coupleMap, 0);
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Set coupled modification
+void dynamicTopoFvMesh::setCoupledModification() const
+{
+    coupledModification_ = true;
+}
+
+
+// Unset coupled modification
+void dynamicTopoFvMesh::unsetCoupledModification() const
+{
+    coupledModification_ = false;
+}
+
+
+// Initialize the coupled stack
+void dynamicTopoFvMesh::initCoupledStack
+(
+    const labelHashSet& entities,
+    bool useEntities
+)
+{
+    // Clear existing lists/stacks.
+    stack(0).clear();
+
+    if (useEntities)
+    {
+        bool emptyEntity;
+
+        // Initialize the stack with entries
+        // in the labelHashSet and return
+        forAllConstIter(labelHashSet, entities, eIter)
+        {
+            // Add only valid entities
+            emptyEntity =
+            (
+                twoDMesh_ ?
+                faces_[eIter.key()].empty() :
+                edgeFaces_[eIter.key()].empty()
+            );
+
+            if (emptyEntity)
+            {
+                continue;
+            }
+
+            stack(0).insert(eIter.key());
+        }
+
+        if (debug > 3 && Pstream::parRun())
+        {
+            Pout<< nl << "Entity stack size: " << stack(0).size() << endl;
+
+            if (debug > 4)
+            {
+                // Write out stack entities
+                labelList stackElements(stack(0).size(), -1);
+
+                forAll(stackElements, elemI)
+                {
+                    stackElements[elemI] = stack(0)[elemI];
+                }
+
+                label elemType = twoDMesh_ ? 2 : 1;
+
+                writeVTK
+                (
+                    "entityStack_"
+                  + Foam::name(Pstream::myProcNo()),
+                    stackElements,
+                    elemType
+                );
+            }
+        }
+
+        return;
+    }
+
+    // Loop though boundary faces and check whether
+    // they belong to master/slave coupled patches.
+    for (label faceI = nOldInternalFaces_; faceI < faces_.size(); faceI++)
+    {
+        // Add only valid faces
+        if (faces_[faceI].empty())
+        {
+            continue;
+        }
+
+        label pIndex = whichPatch(faceI);
+
+        if (pIndex == -1)
+        {
+            continue;
+        }
+
+        // Check if this is a locally coupled master face.
+        if (patchCoupling_.size())
+        {
+            if (patchCoupling_(pIndex))
+            {
+                // Is patch cyclic?
+                bool addIndex = true;
+
+                if (isA<cyclicPolyPatch>(boundaryMesh()[pIndex]))
+                {
+                    // Check if this is a cyclic master face
+                    const coupleMap& cMap = patchCoupling_[pIndex].map();
+                    const Map<label>& fMap = cMap.entityMap(coupleMap::FACE);
+
+                    if (!fMap.found(faceI))
+                    {
+                        addIndex = false;
+                    }
+                }
+
+                // Add this to the coupled modification stack.
+                if (addIndex)
+                {
+                    if (twoDMesh_)
+                    {
+                        stack(0).push(faceI);
+                    }
+                    else
+                    {
+                        const labelList& mfEdges = faceEdges_[faceI];
+
+                        forAll(mfEdges, edgeI)
+                        {
+                            // Add this to the coupled modification stack.
+                            stack(0).push(mfEdges[edgeI]);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Check if this is a processor patch.
+        label neiProcID = getNeighbourProcessor(pIndex);
+
+        if (neiProcID > -1)
+        {
+            // Check if this is a master processor patch.
+            if (neiProcID > Pstream::myProcNo())
+            {
+                // Add this to the coupled modification stack.
+                if (twoDMesh_)
+                {
+                    stack(0).push(faceI);
+                }
+                else
+                {
+                    const label edgeEnum = coupleMap::EDGE;
+                    const labelList& mfEdges = faceEdges_[faceI];
+
+                    forAll(mfEdges, edgeI)
+                    {
+                        label eIndex = mfEdges[edgeI];
+
+                        // Need to avoid this edge if it is
+                        // talking to lower-ranked processors.
+                        bool permissible = true;
+
+                        forAll(procIndices_, pI)
+                        {
+                            if (procIndices_[pI] > Pstream::myProcNo())
+                            {
+                                continue;
+                            }
+
+                            // Fetch reference to subMeshes
+                            const coupledInfo& recvMesh = recvMeshes_[pI];
+                            const coupleMap& rcMap = recvMesh.map();
+
+                            if (rcMap.findSlave(edgeEnum, eIndex) > -1)
+                            {
+                                permissible = false;
+                                break;
+                            }
+                        }
+
+                        if (permissible)
+                        {
+                            stack(0).push(eIndex);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (debug > 3 && Pstream::parRun())
+    {
+        Pout<< nl << "Coupled stack size: " << stack(0).size() << endl;
+
+        if (debug > 4)
+        {
+            // Write out stack entities
+            labelList stackElements(stack(0).size(), -1);
+
+            forAll(stackElements, elemI)
+            {
+                stackElements[elemI] = stack(0)[elemI];
+            }
+
+            label elemType = twoDMesh_ ? 2 : 1;
+
+            writeVTK
+            (
+                "coupledStack_"
+              + Foam::name(Pstream::myProcNo()),
+                stackElements,
+                elemType
+            );
+        }
+    }
+}
+
+
+// Execute load balancing operations on the mesh
+void dynamicTopoFvMesh::executeLoadBalancing
+(
+    const dictionary& balanceDict
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    bool enabled = readBool(balanceDict.lookup("enabled"));
+
+    if (!enabled)
+    {
+        return;
+    }
+
+    // Read interval
+    label interval = readLabel(balanceDict.lookup("interval"));
+
+    // Are we at the interval?
+    if ((interval < 0) || (time().timeIndex() % interval != 0))
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< " void dynamicTopoFvMesh::executeLoadBalancing() :"
+            << " Executing load-balancing operations on the mesh."
+            << endl;
+
+        // Write out patch boundaries before re-distribution
+        for (label pI = 0; pI < nPatches_; pI++)
+        {
+            label neiProcNo = getNeighbourProcessor(pI);
+
+            if (neiProcNo == -1)
+            {
+                continue;
+            }
+
+            writeVTK
+            (
+                "procPatchFacesNew_"
+              + Foam::name(Pstream::myProcNo())
+              + '_'
+              + Foam::name(neiProcNo),
+                identity(patchSizes_[pI]) + patchStarts_[pI],
+                2
+            );
+
+            writeVTK
+            (
+                "procPatchFacesOld_"
+              + Foam::name(Pstream::myProcNo())
+              + '_'
+              + Foam::name(neiProcNo),
+                identity(patchSizes_[pI]) + patchStarts_[pI],
+                2, false, true
+            );
+        }
+    }
+
+    // Read decomposition options and initialize
+    autoPtr<decompositionMethod> decomposerPtr
+    (
+        decompositionMethod::New
+        (
+            balanceDict,
+            (*this)
+        )
+    );
+
+    // Alias for convenience...
+    decompositionMethod& decomposer = decomposerPtr();
+
+    if (!decomposer.parallelAware())
+    {
+        FatalErrorIn("void dynamicTopoFvMesh::executeLoadBalancing()")
+            << "You have selected decomposition method "
+            << decomposer.typeName
+            << " which is not parallel aware." << endl
+            << "Please select one that is (hierarchical, parMetis)"
+            << exit(FatalError);
+    }
+
+    // Calculate a merge-distance
+    const boundBox& box = polyMesh::bounds();
+    scalar mergeTol = readScalar(balanceDict.lookup("mergeTol"));
+
+    // Compute mergeDist
+    scalar mergeDist = mergeTol * box.mag();
+
+    // Compute write tolerance
+    scalar writeTol =
+    (
+        std::pow
+        (
+            scalar(10.0),
+           -scalar(IOstream::defaultPrecision())
+        )
+    );
+
+    Info<< nl
+        << " Overall mesh bounding box  : " << box << nl
+        << " Relative tolerance         : " << mergeTol << nl
+        << " Absolute matching distance : " << mergeDist << nl
+        << endl;
+
+    // Check for compatibility
+    if (time().writeFormat() == IOstream::ASCII && mergeTol < writeTol)
+    {
+        FatalErrorIn("void dynamicTopoFvMesh::executeLoadBalancing()")
+            << " Your current settings specify ASCII writing with "
+            << IOstream::defaultPrecision() << " digits precision." << nl
+            << " Your mergeTol (" << mergeTol << ") is finer than this." << nl
+            << " Remedies: " << nl
+            << "  - Change writeFormat to binary" << nl
+            << "  - Increase writePrecision" << nl
+            << "  - Adjust the merge tolerance (mergeTol)" << endl
+            << exit(FatalError);
+    }
+
+    // Decompose the mesh and obtain distribution
+    labelList cellDistribution
+    (
+        decomposer.decompose
+        (
+            primitiveMesh::cellCentres(),
+            scalarField(nCells_, 1)
+        )
+    );
+
+    // Set the coupledModification switch
+    setCoupledModification();
+
+    // Initialize the mesh distribution engine
+    fvMeshDistribute distributor(*this, mergeDist);
+
+    // Re-distribute mesh according to new decomposition
+    distributor.distribute(cellDistribution);
+
+    // Reset the coupledModification switch
+    unsetCoupledModification();
+
+    // Set old / new sizes
+    nPoints_ = nOldPoints_ = primitiveMesh::nPoints();
+    nEdges_ = nOldEdges_ = 0;
+    nFaces_ = nOldFaces_ = primitiveMesh::nFaces();
+    nCells_ = nOldCells_ = primitiveMesh::nCells();
+    nInternalFaces_ = nOldInternalFaces_ = primitiveMesh::nInternalFaces();
+    nInternalEdges_ = nOldInternalEdges_ = 0;
+
+    // Now re-initialize all connectivity structures
+    oldPoints_ = polyMesh::points();
+    points_ = polyMesh::points();
+    faces_ = polyMesh::faces();
+    owner_ = polyMesh::faceOwner();
+    neighbour_ = polyMesh::faceNeighbour();
+    cells_ = primitiveMesh::cells();
+
+    // Check the size of owner / neighbour
+    if (owner_.size() != neighbour_.size())
+    {
+        // Size up to number of faces
+        neighbour_.setSize(nFaces_, -1);
+    }
+
+    const polyBoundaryMesh& boundary = polyMesh::boundaryMesh();
+
+    // Initialize patch-size information
+    nPatches_ = boundary.size();
+
+    oldPatchSizes_.setSize(nPatches_, 0);
+    oldPatchStarts_.setSize(nPatches_, -1);
+    oldEdgePatchSizes_.setSize(nPatches_, 0);
+    oldEdgePatchStarts_.setSize(nPatches_, -1);
+    oldPatchNMeshPoints_.setSize(nPatches_, -1);
+
+    patchSizes_.setSize(nPatches_, 0);
+    patchStarts_.setSize(nPatches_, -1);
+    edgePatchSizes_.setSize(nPatches_, 0);
+    edgePatchStarts_.setSize(nPatches_, -1);
+    patchNMeshPoints_.setSize(nPatches_, -1);
+
+    for (label i = 0; i < nPatches_; i++)
+    {
+        patchNMeshPoints_[i] = boundary[i].meshPoints().size();
+        oldPatchSizes_[i] = patchSizes_[i] = boundary[i].size();
+        oldPatchStarts_[i] = patchStarts_[i] = boundary[i].start();
+        oldPatchNMeshPoints_[i] = patchNMeshPoints_[i];
+    }
+
+    // Clear pointers and re-initialize
+    mapper_.clear();
+    eMeshPtr_.clear();
+    motionSolver_.clear();
+    lengthEstimator_.clear();
+
+    // Initialize edge-related connectivity structures
+    initEdges();
+
+    // Load the mesh-motion solver
+    loadMotionSolver();
+
+    // Load the field-mapper
+    loadFieldMapper();
+
+    // Set sizes for the reverse maps
+    reversePointMap_.setSize(nPoints_, -7);
+    reverseEdgeMap_.setSize(nEdges_, -7);
+    reverseFaceMap_.setSize(nFaces_, -7);
+    reverseCellMap_.setSize(nCells_, -7);
+
+    // Load the length-scale estimator,
+    // and read refinement options
+    loadLengthScaleEstimator();
+
+    // Clear parallel structures
+    procIndices_.clear();
+    sendMeshes_.clear();
+    recvMeshes_.clear();
+}
+
+
+// Identify coupled patches.
+//  - Also builds global shared point information.
+//  - Returns true if no coupled patches were found.
+bool dynamicTopoFvMesh::identifyCoupledPatches()
+{
+    bool coupledPatchesAbsent = true;
+
+    // Check if patches are explicitly coupled
+    if (patchCoupling_.size())
+    {
+        coupledPatchesAbsent = false;
+    }
+
+    // Maintain a separate list of processor IDs in procIndices.
+    // This is done because this sub-domain may talk to processors
+    // that share only edges/points.
+    if (!Pstream::parRun() || procIndices_.size())
+    {
+        return coupledPatchesAbsent;
+    }
+
+    // Prepare a list of points for sub-mesh creation.
+    //  - Obtain global shared-points information, if necessary.
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Set flag as default for parallel runs
+    coupledPatchesAbsent = false;
+
+    // Fetch the list of global points from polyMesh.
+    //  - This should be the first evaluation of globalData,
+    //    so this involves global communication
+    const globalMeshData& gData = polyMesh::globalData();
+
+    const labelList& spA = gData.sharedPointAddr();
+    const labelList& spL = gData.sharedPointLabels();
+
+    labelListList spB(Pstream::nProcs(), labelList(0));
+
+    if (gData.nGlobalPoints())
+    {
+        if (debug)
+        {
+            Info<< " dynamicTopoFvMesh::identifyCoupledPatches :"
+                << " Found " << gData.nGlobalPoints()
+                << " global points." << endl;
+        }
+
+        // Send others my addressing.
+        for (label proc = 0; proc < Pstream::nProcs(); proc++)
+        {
+            if (proc != Pstream::myProcNo())
+            {
+                // Send number of entities first.
+                meshOps::pWrite(proc, spA.size());
+
+                // Send the buffer.
+                if (spA.size())
+                {
+                    meshOps::pWrite(proc, spA);
+                }
+            }
+        }
+
+        // Receive addressing from others
+        for (label proc = 0; proc < Pstream::nProcs(); proc++)
+        {
+            if (proc != Pstream::myProcNo())
+            {
+                label procInfoSize = -1;
+
+                // How many entities am I going to be receiving?
+                meshOps::pRead(proc, procInfoSize);
+
+                if (procInfoSize)
+                {
+                    // Size the receive buffer.
+                    spB[proc].setSize(procInfoSize, -1);
+
+                    // Schedule for receipt.
+                    meshOps::pRead(proc, spB[proc]);
+                }
+            }
+        }
+    }
+    else
+    if (debug)
+    {
+        Info<< " dynamicTopoFvMesh::identifyCoupledPatches :"
+            << " Did not find any global points." << endl;
+    }
+
+    Map<label> immNeighbours;
+    labelListList procPoints(Pstream::nProcs());
+
+    // Track globally shared points
+    List<DynamicList<labelPair> > globalProcPoints
+    (
+        Pstream::nProcs(),
+        DynamicList<labelPair>(5)
+    );
+
+    // Insert my immediate neighbours into the list.
+    forAll(boundary, pI)
+    {
+        if (isA<processorPolyPatch>(boundary[pI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[pI])
+            );
+
+            label neiProcNo = pp.neighbProcNo();
+
+            // Insert all boundary points.
+            procPoints[neiProcNo] = pp.meshPoints();
+
+            // Keep track of immediate neighbours.
+            immNeighbours.insert(neiProcNo, pI);
+        }
+    }
+
+    if (gData.nGlobalPoints())
+    {
+        // Wait for all transfers to complete.
+        meshOps::waitForBuffers();
+
+        // Now loop through all processor addressing, and check if
+        // any labels coincide with my global shared points.
+        // If this is true, we need to be talking to that neighbour
+        // as well (if not already).
+        for (label proc = 0; proc < Pstream::nProcs(); proc++)
+        {
+            if (proc == Pstream::myProcNo())
+            {
+                continue;
+            }
+
+            bool foundGlobalMatch = false;
+
+            // Fetch reference to buffer
+            const labelList& procBuffer = spB[proc];
+
+            forAll(procBuffer, pointI)
+            {
+                forAll(spA, pointJ)
+                {
+                    if (spA[pointJ] == procBuffer[pointI])
+                    {
+                        // Make an entry, if one wasn't made already
+                        if (findIndex(procPoints[proc], spL[pointJ]) == -1)
+                        {
+                            globalProcPoints[proc].append
+                            (
+                                labelPair(spL[pointJ], spA[pointJ])
+                            );
+                        }
+
+                        foundGlobalMatch = true;
+
+                        break;
+                    }
+                }
+            }
+
+            if (!immNeighbours.found(proc))
+            {
+                if (foundGlobalMatch && debug)
+                {
+                    Pout<< " dynamicTopoFvMesh::identifyCoupledPatches :"
+                        << " Additionally talking to processor: "
+                        << proc << endl;
+                }
+            }
+        }
+    }
+
+    // Estimate an initial size
+    procIndices_.setSize(Pstream::nProcs());
+
+    // Patch sub meshes need to be prepared in ascending
+    // order of neighbouring processors.
+    label nTotalProcs = 0;
+
+    forAll(procPoints, procI)
+    {
+        if (procPoints[procI].size())
+        {
+            procIndices_[nTotalProcs++] = procI;
+        }
+
+        // Check for point / edge coupling
+        if (globalProcPoints[procI].size() && !procPoints[procI].size())
+        {
+            procIndices_[nTotalProcs++] = procI;
+        }
+    }
+
+    // Shrink to actual size
+    procIndices_.setSize(nTotalProcs);
+
+    // Size the PtrLists.
+    sendMeshes_.setSize(nTotalProcs);
+    recvMeshes_.setSize(nTotalProcs);
+
+    // Create send/recv patch meshes, and copy
+    // the list of points for each processor.
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI], master = -1, slave = -1;
+
+        // For processors that have only point / edge coupling
+        // specify an invalid patch ID for now
+        label patchID = immNeighbours.found(proc) ? immNeighbours[proc] : -1;
+
+        if (proc < Pstream::myProcNo())
+        {
+            master = proc;
+            slave = Pstream::myProcNo();
+        }
+        else
+        {
+            master = Pstream::myProcNo();
+            slave = proc;
+        }
+
+        sendMeshes_.set
+        (
+            pI,
+            new coupledInfo
+            (
+                *this,               // Reference to this mesh
+                twoDMesh_,           // 2D or 3D
+                false,               // Not local
+                true,                // Sent to neighbour
+                patchID,             // Patch index
+                master,              // Master index
+                slave                // Slave index
+            )
+        );
+
+        sendMeshes_[pI].map().subMeshPoints() =
+        (
+            procPoints[procIndices_[pI]]
+        );
+
+        sendMeshes_[pI].map().globalProcPoints() =
+        (
+            globalProcPoints[procIndices_[pI]]
+        );
+
+        recvMeshes_.set
+        (
+            pI,
+            new coupledInfo
+            (
+                *this,               // Reference to this mesh
+                twoDMesh_,           // 2D or 3D
+                false,               // Not local
+                false,               // Not sent to neighbour
+                patchID,             // Patch index
+                master,              // Master index
+                slave                // Slave index
+            )
+        );
+
+        recvMeshes_[pI].map().subMeshPoints() =
+        (
+            procPoints[procIndices_[pI]]
+        );
+
+        recvMeshes_[pI].map().globalProcPoints() =
+        (
+            globalProcPoints[procIndices_[pI]]
+        );
+    }
+
+    if (debug > 3)
+    {
+        Pout<< " identifyCoupledPatches :"
+            << " Talking to processors: "
+            << procIndices_ << endl;
+
+        forAll(procIndices_, pI)
+        {
+            label proc = procIndices_[pI];
+
+            const List<labelPair>* gppPtr = NULL;
+
+            // Write out subMeshPoints as a VTK
+            if (proc < Pstream::myProcNo())
+            {
+                const coupleMap& cMap = sendMeshes_[pI].map();
+
+                writeVTK
+                (
+                    "subMeshPoints_" +
+                    Foam::name(Pstream::myProcNo()) + "to" +
+                    Foam::name(proc),
+                    cMap.subMeshPoints(),
+                    0
+                );
+
+                // Fetch reference
+                gppPtr = &(cMap.globalProcPoints());
+            }
+            else
+            {
+                const coupleMap& cMap = sendMeshes_[pI].map();
+
+                writeVTK
+                (
+                    "subMeshPoints_" +
+                    Foam::name(Pstream::myProcNo()) + "to" +
+                    Foam::name(proc),
+                    cMap.subMeshPoints(),
+                    0
+                );
+
+                // Fetch reference
+                gppPtr = &(cMap.globalProcPoints());
+            }
+
+            // Write out globalProcPoints as a VTK
+            const List<labelPair>& gpp = *gppPtr;
+
+            if (gpp.size())
+            {
+                labelList gpPoints(gpp.size(), -1);
+
+                forAll(gpp, pointI)
+                {
+                    gpPoints[pointI] = gpp[pointI].first();
+                }
+
+                writeVTK
+                (
+                    "globalProcPoints_" +
+                    Foam::name(Pstream::myProcNo()) + "to" +
+                    Foam::name(proc),
+                    gpPoints,
+                    0
+                );
+            }
+        }
+    }
+
+    return coupledPatchesAbsent;
+}
+
+
+// Read coupled patch information from dictionary.
+void dynamicTopoFvMesh::readCoupledPatches()
+{
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Clear list
+    patchCoupling_.clear();
+
+    if (dict_.found("coupledPatches") || mandatory_)
+    {
+        // Size the initial list
+        patchCoupling_.setSize(boundary.size());
+
+        const dictionary& coupledPatches = dict_.subDict("coupledPatches");
+
+        // Determine master and slave patches
+        forAllConstIter(dictionary, coupledPatches, dIter)
+        {
+            const dictionary& dictI = dIter().dict();
+
+            // Lookup the master / slave patches
+            word masterPatch = dictI.lookup("master");
+            word slavePatch = dictI.lookup("slave");
+
+            // Determine patch indices
+            label mPatch = boundary.findPatchID(masterPatch);
+            label sPatch = boundary.findPatchID(slavePatch);
+
+            if (debug)
+            {
+                Info<< " Adding master: " << masterPatch << " : " << mPatch
+                    << " with slave: " << slavePatch << " : " << sPatch
+                    << endl;
+            }
+
+            // Add to the list if entries are legitimate
+            if
+            (
+                mPatch != sPatch &&
+                boundary[mPatch].size() == boundary[sPatch].size()
+            )
+            {
+                // Check whether patches are associated with zones.
+                Switch specifyZones
+                (
+                    dictI.lookup("specifyZones")
+                );
+
+                label mZone = -1, sZone = -1;
+
+                if (specifyZones)
+                {
+                    const faceZoneMesh& faceZones = polyMesh::faceZones();
+
+                    mZone = faceZones.findZoneID
+                    (
+                        dictI.lookup("masterZone")
+                    );
+
+                    sZone = faceZones.findZoneID
+                    (
+                        dictI.lookup("slaveZone")
+                    );
+                }
+
+                // Configure with regIOobject for check-in
+                coupleMap cMap
+                (
+                    IOobject
+                    (
+                        "coupleMap_"
+                      + Foam::name(mPatch)
+                      + "_To_"
+                      + Foam::name(sPatch)
+                      + "_Local",
+                        time().timeName(),
+                        *this,
+                        IOobject::READ_IF_PRESENT,
+                        IOobject::AUTO_WRITE,
+                        true
+                    ),
+                    twoDMesh_,
+                    true,
+                    false,
+                    mPatch,
+                    mPatch,
+                    sPatch
+                );
+
+                // Set the pointer
+                patchCoupling_.set
+                (
+                    mPatch,
+                    new coupledInfo
+                    (
+                        *this,
+                        cMap,
+                        mZone,
+                        sZone
+                    )
+                );
+            }
+            else
+            {
+                FatalErrorIn("void dynamicTopoFvMesh::readCoupledPatches()")
+                    << " Coupled patches are either wrongly specified,"
+                    << " or the sizes don't match." << nl
+                    << " Master: " << mPatch << ":" << masterPatch
+                    << " Size: " << boundary[mPatch].size() << nl
+                    << " Slave: " << sPatch << ":" << slavePatch
+                    << " Size: " << boundary[sPatch].size() << nl
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Loop through boundaries and add any cyclic patches
+    forAll(boundary, patchI)
+    {
+        if (!isA<cyclicPolyPatch>(boundary[patchI]))
+        {
+            continue;
+        }
+
+        // Size up patchCoupling, if necessary
+        if (patchCoupling_.empty())
+        {
+            patchCoupling_.setSize(boundary.size());
+        }
+
+        if (debug)
+        {
+            Info<< " Adding cyclic: " << patchI
+                << " : " << boundary[patchI].name()
+                << endl;
+        }
+
+        // Configure with regIOobject for check-in
+        coupleMap cMap
+        (
+            IOobject
+            (
+                "coupleMap_"
+              + Foam::name(patchI)
+              + "_To_"
+              + Foam::name(patchI)
+              + "_Local",
+                time().timeName(),
+                *this,
+                IOobject::READ_IF_PRESENT,
+                IOobject::AUTO_WRITE,
+                true
+            ),
+            twoDMesh_,
+            true,
+            false,
+            patchI,
+            patchI,
+            patchI
+        );
+
+        // Set the pointer
+        patchCoupling_.set
+        (
+            patchI,
+            new coupledInfo(*this, cMap, -1, -1)
+        );
+    }
+}
+
+
+// Initialize coupled patch connectivity for topology modifications.
+//  - Send and receive sub meshes for processor patches.
+//  - Made static because this function may be run in a separate thread.
+void dynamicTopoFvMesh::initCoupledConnectivity
+(
+    void *argument
+)
+{
+    // Recast the argument
+    dynamicTopoFvMesh *mesh = static_cast<dynamicTopoFvMesh*>(argument);
+
+    // Identify coupled patches.
+    if (mesh->identifyCoupledPatches())
+    {
+        return;
+    }
+
+    // Build and send patch sub-meshes.
+    mesh->buildProcessorPatchMeshes();
+
+    // Build inital maps for locally coupled patches.
+    mesh->buildLocalCoupledMaps();
+
+    // Build maps for coupled processor patches.
+    mesh->buildProcessorCoupledMaps();
+}
+
+
+// Move coupled subMesh points
+void dynamicTopoFvMesh::moveCoupledSubMeshes()
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< " void dynamicTopoFvMesh::moveCoupledSubMeshes() :"
+            << " Moving points for coupled subMeshes."
+            << endl;
+    }
+
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        const coupledInfo& sPM = sendMeshes_[pI];
+        const coupledInfo& rPM = recvMeshes_[pI];
+
+        // Fetch the coupleMap
+        const coupleMap& scMap = sPM.map();
+        const coupleMap& rcMap = rPM.map();
+
+        Map<label>& pointMap = scMap.entityMap(coupleMap::POINT);
+
+        // Fill point buffers
+        pointField& pBuffer = scMap.pointBuffer();
+        pointField& opBuffer = scMap.oldPointBuffer();
+
+        forAllConstIter(Map<label>, pointMap, pIter)
+        {
+            pBuffer[pIter.key()] = points_[pIter()];
+            opBuffer[pIter.key()] = oldPoints_[pIter()];
+        }
+
+        // Buffers have already been allocated
+        // to the right size, so just transfer points
+
+        // Send point buffers to neighbour
+        meshOps::pWrite(proc, scMap.pointBuffer());
+        meshOps::pWrite(proc, scMap.oldPointBuffer());
+
+        // Receive point buffers from neighbour
+        meshOps::pRead(proc, rcMap.pointBuffer());
+        meshOps::pRead(proc, rcMap.oldPointBuffer());
+    }
+
+    // Wait for transfers to complete before moving on
+    meshOps::waitForBuffers();
+
+    // Set points in mesh
+    forAll(procIndices_, pI)
+    {
+        // Fetch non-const reference to patchSubMesh
+        coupledInfo& rPM = recvMeshes_[pI];
+
+        // Fetch the coupleMap
+        const coupleMap& rcMap = rPM.map();
+
+        dynamicTopoFvMesh& mesh = rPM.subMesh();
+        const polyBoundaryMesh& boundary = mesh.boundaryMesh();
+
+        // Set points / oldPoints
+        mesh.points_ = rcMap.pointBuffer();
+        mesh.oldPoints_ = rcMap.oldPointBuffer();
+
+        labelList patchSizes(boundary.size(), -1);
+        labelList patchStarts(boundary.size(), -1);
+
+        forAll(boundary, patchI)
+        {
+            patchSizes[patchI] = boundary[patchI].size();
+            patchStarts[patchI] = boundary[patchI].start();
+        }
+
+        // Reset underlying mesh.
+        //  - Use null lists for addressing to avoid over-writes
+        //  - Specify non-valid boundary to avoid globalData creation
+        mesh.resetPrimitives
+        (
+            xferCopy(rcMap.oldPointBuffer()),
+            Xfer<faceList>::null(),
+            Xfer<labelList>::null(),
+            Xfer<labelList>::null(),
+            patchSizes,
+            patchStarts,
+            false
+        );
+    }
+}
+
+
+// Insert the cells around the coupled master entity to the mesh
+// - Returns a changeMap with a type specifying:
+//     1: Insertion was successful
+//    -1: Insertion failed
+//    -2: Failed because entity was being handled elsewhere
+// - The changeMap index specifies the converted mIndex.
+const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
+{
+    // Prepare the changeMaps
+    changeMap map;
+
+    // Maintain face counts for each inserted cell
+    Map<label> nCellFaces;
+
+    // Track inserted entities
+    List<Map<label> > pointsToInsert(procIndices_.size());
+    List<Map<label> > edgesToInsert(procIndices_.size());
+    List<Map<label> > facesToInsert(procIndices_.size());
+    List<Map<label> > cellsToInsert(procIndices_.size());
+
+    // Track converted entities
+    List<Map<label> > edgesToConvert(procIndices_.size());
+    List<Map<label> > facesToConvert(procIndices_.size());
+
+    // Track edge / face patch information
+    List<Map<label> > masterConvertEdgePatch(procIndices_.size());
+    List<Map<label> > masterConvertFacePatch(procIndices_.size());
+
+    Map<label> createPatch;
+    labelList slaveConvertPatch(procIndices_.size(), -1);
+    List<Map<Pair<point> > > convertPatchPoints(procIndices_.size());
+
+    // First check to ensure that this case can be handled
+    forAll(procIndices_, pI)
+    {
+        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+
+        // Fetch reference to maps
+        const coupleMap& cMap = recvMeshes_[pI].map();
+
+        // Does a coupling exist?
+        if (cMap.findSlave(cplEnum, mIndex) == -1)
+        {
+            continue;
+        }
+
+        // If this entity is being handled elsewhere, bail out
+        if (procIndices_[pI] < Pstream::myProcNo())
+        {
+            map.type() = -2;
+
+            return map;
+        }
+    }
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Agglomerate cells from surrounding subMeshes
+    forAll(procIndices_, pI)
+    {
+        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+
+        // Fetch reference to maps
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        label sIndex = -1;
+
+        if ((sIndex = cMap.findSlave(cplEnum, mIndex)) == -1)
+        {
+            continue;
+        }
+
+        // Fetch references
+        Map<label>& procCellMap = cellsToInsert[pI];
+
+        if (twoDMesh_)
+        {
+            // Insert the owner cell
+            procCellMap.insert(mesh.owner_[sIndex], -1);
+        }
+        else
+        {
+            // Insert all cells connected to this edge
+            const labelList& eFaces = mesh.edgeFaces_[sIndex];
+
+            forAll(eFaces, faceI)
+            {
+                const label own = mesh.owner_[eFaces[faceI]];
+                const label nei = mesh.neighbour_[eFaces[faceI]];
+
+                if (!procCellMap.found(own))
+                {
+                    procCellMap.insert(own, -1);
+                }
+
+                if (!procCellMap.found(nei) && (nei != -1))
+                {
+                    procCellMap.insert(nei, -1);
+                }
+            }
+        }
+
+        // Find a patch that talks to this processor
+        label neiProcPatch = -1;
+
+        forAll(boundary, patchI)
+        {
+            if (getNeighbourProcessor(patchI) == procIndices_[pI])
+            {
+                neiProcPatch = patchI;
+                break;
+            }
+        }
+
+        // Prepare information about inserted / converted faces and edges
+        const polyBoundaryMesh& slaveBoundary = mesh.boundaryMesh();
+
+        // Set the slave conversion patch
+        forAll(slaveBoundary, patchI)
+        {
+            if (mesh.getNeighbourProcessor(patchI) == Pstream::myProcNo())
+            {
+                slaveConvertPatch[pI] = patchI;
+                break;
+            }
+        }
+
+        forAllIter(Map<label>, procCellMap, cIter)
+        {
+            const cell& checkCell = mesh.cells_[cIter.key()];
+
+            forAll(checkCell, fI)
+            {
+                label mfIndex = -1, sfIndex = checkCell[fI];
+                label sfPatch = mesh.whichPatch(sfIndex);
+
+                // Check whether a face mapping exists for this face
+                if ((mfIndex = cMap.findMaster(coupleMap::FACE, sfIndex)) > -1)
+                {
+                    // Mark as a candidate for conversion
+                    facesToInsert[pI].insert(sfIndex, mfIndex);
+                    facesToConvert[pI].insert(sfIndex, mfIndex);
+                }
+                else
+                {
+                    // Mark for insertion. Some faces may be duplicated
+                    // across processors, but this will be dealt
+                    // with at a later stage.
+                    facesToInsert[pI].insert(sfIndex, -1);
+                }
+
+                // Check face points for coupling
+                const face& sFace = mesh.faces_[sfIndex];
+
+                // Configure points which need to be inserted
+                forAll(sFace, pointI)
+                {
+                    // Skip if added already
+                    if (pointsToInsert[pI].found(sFace[pointI]))
+                    {
+                        continue;
+                    }
+
+                    // Check for coupled points
+                    pointsToInsert[pI].insert
+                    (
+                        sFace[pointI],
+                        cMap.findMaster
+                        (
+                            coupleMap::POINT,
+                            sFace[pointI]
+                        )
+                    );
+                }
+
+                // Loop through edges and check whether edge-mapping exists
+                const labelList& sfEdges = mesh.faceEdges_[sfIndex];
+
+                forAll(sfEdges, edgeI)
+                {
+                    const label seIndex = sfEdges[edgeI];
+                    const edge& sEdge = mesh.edges_[seIndex];
+
+                    // Meshes in 2D don't have edge-mapping, so check
+                    // point maps instead. If either point doesn't exist,
+                    // this is an edge that needs to be inserted.
+                    label cMs = cMap.findMaster(coupleMap::POINT, sEdge[0]);
+                    label cMe = cMap.findMaster(coupleMap::POINT, sEdge[1]);
+
+                    if (!edgesToInsert[pI].found(seIndex))
+                    {
+                        edgesToInsert[pI].insert(seIndex, -1);
+                    }
+
+                    // If both points have maps, this is a conversion edge
+                    if (cMs > -1 && cMe > -1)
+                    {
+                        if (!edgesToConvert[pI].found(seIndex))
+                        {
+                            edgesToConvert[pI].insert(seIndex, -1);
+                        }
+                    }
+
+                    // Add a patch entry as well
+                    if (masterConvertEdgePatch[pI].found(seIndex))
+                    {
+                        continue;
+                    }
+
+                    label edgePatch = -1;
+                    label sePatch = mesh.whichEdgePatch(seIndex);
+                    label neiProcNo = mesh.getNeighbourProcessor(sePatch);
+
+                    // Determine patch
+                    if (sePatch == -1)
+                    {
+                        // Slave edge was an interior one
+                        edgePatch = neiProcPatch;
+                    }
+                    else
+                    if (sePatch == (slaveBoundary.size() - 1))
+                    {
+                        // The 'defaultPatch'
+                        edgePatch = neiProcPatch;
+                    }
+                    else
+                    if (neiProcNo > -1)
+                    {
+                        if (neiProcNo == Pstream::myProcNo())
+                        {
+                            // Set the master edge patch
+                            edgePatch = neiProcPatch;
+                        }
+                        else
+                        {
+                            // If this other processor is
+                            // lesser-ranked, bail out.
+                            if (neiProcNo < Pstream::myProcNo())
+                            {
+                                map.type() = -2;
+
+                                return map;
+                            }
+                            else
+                            if (debug > 3)
+                            {
+                                Pout<< nl << nl
+                                    << " Edge: " << seIndex
+                                    << " :: " << mesh.edges_[seIndex]
+                                    << " is talking to processor: "
+                                    << neiProcNo << endl;
+                            }
+
+                            // Find an appropriate boundary patch
+                            forAll(boundary, patchI)
+                            {
+                                label eP = getNeighbourProcessor(patchI);
+
+                                if (eP == neiProcNo)
+                                {
+                                    edgePatch = patchI;
+                                    break;
+                                }
+                            }
+
+                            if (edgePatch == -1)
+                            {
+                                if (debug > 3)
+                                {
+                                    Pout<< nl << nl
+                                        << " No direct contact with"
+                                        << " processor: " << neiProcNo
+                                        << " so adding to: " << neiProcPatch
+                                        << endl;
+                                }
+
+                                // Add this to neiProcPatch instead.
+                                edgePatch = neiProcPatch;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // Physical type
+                        edgePatch = sePatch;
+                    }
+
+                    if (edgePatch == -1)
+                    {
+                        // Write out the edge
+                        mesh.writeVTK("seEdge", seIndex, 1);
+
+                        Pout<< " Could not find correct patch info: " << nl
+                            << " seIndex: " << seIndex << nl
+                            << " sePatch: " << sePatch << nl
+                            << " neiProcPatch: " << neiProcPatch << nl
+                            << " Patch Name: " <<
+                            (
+                                sePatch > -1 ?
+                                slaveBoundary[sePatch].name() :
+                                "Internal"
+                            )
+                            << abort(FatalError);
+                    }
+
+                    // Add the patch entry
+                    masterConvertEdgePatch[pI].insert
+                    (
+                        seIndex,
+                        edgePatch
+                    );
+                }
+
+                // Determine patch
+                if (masterConvertFacePatch[pI].found(sfIndex))
+                {
+                    continue;
+                }
+
+                label facePatch = -1;
+                label neiProcNo = mesh.getNeighbourProcessor(sfPatch);
+
+                if (sfPatch == -1)
+                {
+                    // Slave face was an interior one
+                    facePatch = neiProcPatch;
+                }
+                else
+                if (sfPatch == (slaveBoundary.size() - 1))
+                {
+                    // The 'defaultPatch'
+                    facePatch = neiProcPatch;
+                }
+                else
+                if (neiProcNo > -1)
+                {
+                    if (neiProcNo == Pstream::myProcNo())
+                    {
+                        // Check to see if this face was converted before
+                        if
+                        (
+                            findIndex
+                            (
+                                cMap.entityOperations(),
+                                coupleMap::CONVERT_PATCH
+                            ) > -1
+                        )
+                        {
+                            // Loop through points and check for match
+                            const pointField& pts = cMap.moveNewPoints();
+                            const face& fCheck = mesh.faces_[sfIndex];
+                            const point fC = fCheck.centre(mesh.points_);
+
+                            scalar tol = mag(fC - mesh.points_[fCheck[0]]);
+
+                            forAll(pts, ptI)
+                            {
+                                scalar dist = mag(fC - pts[ptI]);
+
+                                if (dist < (1e-4 * tol))
+                                {
+                                    // Face was converted before
+                                    if (debug > 3)
+                                    {
+                                        Pout<< nl << nl
+                                            << " Face: " << sfIndex
+                                            << " :: " << mesh.faces_[sfIndex]
+                                            << " was converted before."
+                                            << endl;
+                                    }
+
+                                    map.type() = -2;
+
+                                    return map;
+                                }
+                            }
+                        }
+
+                        // Set the master face patch
+                        facePatch = neiProcPatch;
+                    }
+                    else
+                    {
+                        // If this other processor is
+                        // lesser-ranked, bail out.
+                        if (neiProcNo < Pstream::myProcNo())
+                        {
+                            map.type() = -2;
+
+                            return map;
+                        }
+                        else
+                        if (debug > 3)
+                        {
+                            Pout<< nl << nl
+                                << " Face: " << sfIndex
+                                << " :: " << mesh.faces_[sfIndex]
+                                << " is talking to processor: "
+                                << neiProcNo << endl;
+                        }
+
+                        // Find an appropriate boundary patch
+                        forAll(boundary, patchI)
+                        {
+                            label fP = getNeighbourProcessor(patchI);
+
+                            if (fP == neiProcNo)
+                            {
+                                facePatch = patchI;
+                                break;
+                            }
+                        }
+
+                        // Specify a convert-patch operation
+                        // for later, if this operation succeeds
+                        const face& sfCheck = mesh.faces_[sfIndex];
+
+                        point nfC = sfCheck.centre(mesh.points_);
+                        point ofC = sfCheck.centre(mesh.oldPoints_);
+
+                        // Are we talking to this processor already?
+                        label prI = findIndex(procIndices_, neiProcNo);
+
+                        // Check for face-contact
+                        if (facePatch == -1)
+                        {
+                            if (debug > 3)
+                            {
+                                Pout<< nl << nl
+                                    << " No face contact with"
+                                    << " processor: " << neiProcNo
+                                    << endl;
+                            }
+
+                            if (prI == -1)
+                            {
+                                Pout<< " No contact with: " << neiProcNo
+                                    << abort(FatalError);
+                            }
+
+                            label pIdx =
+                            (
+                                sendMeshes_[prI].map().patchIndex()
+                            );
+
+                            // Add a patch creation order, if necessary
+                            if (pIdx == -1 && !createPatch.found(neiProcNo))
+                            {
+                                createPatch.insert(neiProcNo, -1);
+                            }
+
+                            // Specify a value for facePatch:
+                            //  - Specify a value that we can use
+                            //    to back out the patch after creation
+                            //  - Also needs to bypass failure check
+                            facePatch = (-2 - neiProcNo);
+                        }
+
+                        // Add to the list
+                        convertPatchPoints[prI].insert
+                        (
+                            sfIndex,
+                            Pair<point>(nfC, ofC)
+                        );
+                    }
+                }
+                else
+                {
+                    // Physical type
+                    facePatch = sfPatch;
+                }
+
+                if (facePatch == -1)
+                {
+                    // Write out the face
+                    mesh.writeVTK("sfFace", sfIndex, 2);
+
+                    Pout<< " Could not find correct patch info: " << nl
+                        << " sfIndex: " << sfIndex << nl
+                        << " sfPatch: " << sfPatch << nl
+                        << " neiProcPatch: " << neiProcPatch << nl
+                        << " slavePatch: " <<
+                        (
+                            sfPatch > -1 ?
+                            slaveBoundary[sfPatch].name() :
+                            "Internal"
+                        )
+                        << abort(FatalError);
+                }
+
+                // Add the patch entry
+                masterConvertFacePatch[pI].insert
+                (
+                    sfIndex,
+                    facePatch
+                );
+            }
+        }
+    }
+
+    // Perform a few debug calls before modifications
+    if (debug > 1)
+    {
+        Pout<< nl << nl
+            << "Inserting cell(s) around coupled "
+            << (twoDMesh_ ? "face: " : "edge: ") << mIndex
+            << endl;
+    }
+
+    // Check to see if any new processor
+    // patches need to be created
+    forAllIter(Map<label>, createPatch, procIter)
+    {
+        label neiProcNo = procIter.key();
+
+        // Create a new processor patch
+        procIter() = createProcessorPatch(neiProcNo);
+
+        forAll(masterConvertFacePatch, pI)
+        {
+            Map<label>& convertMap = masterConvertFacePatch[pI];
+
+            forAllIter(Map<label>, convertMap, mIter)
+            {
+                if (mIter() < 0)
+                {
+                    // Back out the neighbouring processor ID
+                    label proc = Foam::mag(mIter() + 2);
+
+                    if (proc == neiProcNo)
+                    {
+                        // Set the index
+                        mIter() = procIter();
+                    }
+                }
+            }
+        }
+
+        // Find index in processor list
+        label pI = findIndex(procIndices_, neiProcNo);
+
+        if (pI == -1)
+        {
+            Pout<< " Could not find index for processor: " << neiProcNo
+                << " in indices: " << procIndices_
+                << abort(FatalError);
+        }
+
+        // Create patch on subMesh
+        dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        mesh.createProcessorPatch(Pstream::myProcNo());
+    }
+
+    // Build a list of mapping entities on this processor
+    DynamicList<label> mapCells(10);
+
+    if (twoDMesh_)
+    {
+        label own = owner_[mIndex];
+
+        mapCells.append(own);
+    }
+    else
+    {
+        const labelList& eFaces = edgeFaces_[mIndex];
+
+        forAll(eFaces, faceI)
+        {
+            label own = owner_[eFaces[faceI]];
+            label nei = neighbour_[eFaces[faceI]];
+
+            if (findIndex(mapCells, own) == -1)
+            {
+                mapCells.append(own);
+            }
+
+            if (nei > -1)
+            {
+                if (findIndex(mapCells, nei) == -1)
+                {
+                    mapCells.append(nei);
+                }
+            }
+        }
+    }
+
+    // Loop through insertion cells and
+    // create an equivalent on this mesh
+    forAll(procIndices_, pI)
+    {
+        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+
+        // Fetch reference to maps
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        label sIndex = -1;
+
+        if ((sIndex = cMap.findSlave(cplEnum, mIndex)) == -1)
+        {
+            continue;
+        }
+
+        // Fetch references
+        Map<label>& procCellMap = cellsToInsert[pI];
+
+        forAllIter(Map<label>, procCellMap, cIter)
+        {
+            const cell& checkCell = mesh.cells_[cIter.key()];
+
+            scalar sLengthScale = -1.0;
+
+            if (edgeRefinement_)
+            {
+                sLengthScale = mesh.lengthScale_[cIter.key()];
+            }
+
+            // Add an empty cell for now, and update
+            // with face information at a later stage.
+            cIter() = insertCell(cell(checkCell.size()), sLengthScale);
+
+            // Initialize a face counter
+            nCellFaces.insert(cIter(), 0);
+
+            if (debug > 3)
+            {
+                Pout<< " Map cell: " << cIter()
+                    << " for cell: " << cIter.key()
+                    << " on proc: " << procIndices_[pI]
+                    << endl;
+            }
+
+            // Add this cell to the map.
+            map.addCell(cIter(), mapCells);
+
+            // Set basic mapping for this cell
+            setCellMapping(cIter(), mapCells);
+        }
+
+        // Push operation for the slave into coupleMap
+        cMap.pushOperation
+        (
+            sIndex,
+            coupleMap::REMOVE_CELL
+        );
+    }
+
+    // Build a list of edges that need to be converted to interior.
+    // - Do this by looking at edges of master face conversion candidates.
+    // - Some edges may not need conversion, but deal with this later.
+    forAll(facesToConvert, pI)
+    {
+        // Fetch reference to subMesh
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        const Map<label>& procFaceMap = facesToConvert[pI];
+
+        forAllConstIter(Map<label>, procFaceMap, fIter)
+        {
+            const labelList& mfEdges = faceEdges_[fIter()];
+            const labelList& sfEdges = mesh.faceEdges_[fIter.key()];
+
+            forAll(sfEdges, edgeI)
+            {
+                if (edgesToInsert[pI][sfEdges[edgeI]] != -1)
+                {
+                    // Already mapped this edge. Move on.
+                    continue;
+                }
+
+                // Configure the comparison edge
+                const edge& sEdge = mesh.edges_[sfEdges[edgeI]];
+
+                label cMs = cMap.findMaster(coupleMap::POINT, sEdge[0]);
+                label cMe = cMap.findMaster(coupleMap::POINT, sEdge[1]);
+
+                edge cEdge(cMs, cMe);
+
+                forAll(mfEdges, edgeJ)
+                {
+                    const edge& mEdge = edges_[mfEdges[edgeJ]];
+
+                    if (mEdge == cEdge)
+                    {
+                        edgesToInsert[pI][sfEdges[edgeI]] = mfEdges[edgeJ];
+                        edgesToConvert[pI][sfEdges[edgeI]] = mfEdges[edgeJ];
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Loop through all insertion points, and merge if necessary
+    scalar mergeTol =
+    (
+        twoDMesh_ ? 0.0 : 1e-4 * mag(edges_[mIndex].vec(points_))
+    );
+
+    // Insert all points
+    forAll(pointsToInsert, pI)
+    {
+        Map<label>& procPointMapI = pointsToInsert[pI];
+
+        // Fetch reference to subMesh
+        const coupleMap& cMapI = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& meshI = recvMeshes_[pI].subMesh();
+
+        forAllIter(Map<label>, procPointMapI, pItI)
+        {
+            if (pItI() != -1)
+            {
+                continue;
+            }
+
+            const point& pointI = meshI.points_[pItI.key()];
+
+            bool foundMerge = false;
+
+            forAll(pointsToInsert, pJ)
+            {
+                if (pJ == pI)
+                {
+                    continue;
+                }
+
+                Map<label>& procPointMapJ = pointsToInsert[pJ];
+
+                // Fetch reference to subMesh
+                const coupleMap& cMapJ = recvMeshes_[pJ].map();
+                const dynamicTopoFvMesh& meshJ = recvMeshes_[pJ].subMesh();
+
+                // Compare points with this processor
+                forAllIter(Map<label>, procPointMapJ, pItJ)
+                {
+                    const point& pointJ = meshJ.points_[pItJ.key()];
+
+                    if (mag(pointI - pointJ) < mergeTol)
+                    {
+                        if (pItJ() == -1)
+                        {
+                            // Make a merge entry
+                            label mergePointIndex =
+                            (
+                                insertPoint
+                                (
+                                    pointJ,
+                                    meshJ.oldPoints_[pItJ.key()],
+                                    labelList(1, -1)
+                                )
+                            );
+
+                            pItI() = mergePointIndex;
+                            pItJ() = mergePointIndex;
+
+                            // Update maps for the new point
+                            cMapI.mapSlave
+                            (
+                                coupleMap::POINT,
+                                pItI(), pItI.key()
+                            );
+
+                            cMapI.mapMaster
+                            (
+                                coupleMap::POINT,
+                                pItI.key(), pItI()
+                            );
+
+                            cMapJ.mapSlave
+                            (
+                                coupleMap::POINT,
+                                pItJ(), pItJ.key()
+                            );
+
+                            cMapJ.mapMaster
+                            (
+                                coupleMap::POINT,
+                                pItJ.key(), pItJ()
+                            );
+
+                            if (debug > 2)
+                            {
+                                Pout<< " Map point: " << mergePointIndex
+                                    << " pointI: " << pItI.key()
+                                    << " procI: " << procIndices_[pI]
+                                    << " pointJ: " << pItJ.key()
+                                    << " procJ: " << procIndices_[pJ]
+                                    << endl;
+                            }
+
+                            // Add this point to the map.
+                            map.addPoint(mergePointIndex);
+                        }
+                        else
+                        {
+                            // Point appears to have been inserted
+                            // by a previous operation. Map to it.
+                            if (debug > 2)
+                            {
+                                Pout<< " Inserted point: " << pItJ()
+                                    << " pointI: " << pItI.key()
+                                    << " procI: " << procIndices_[pI]
+                                    << " pointJ: " << pItJ.key()
+                                    << " procJ: " << procIndices_[pJ]
+                                    << endl;
+                            }
+
+                            // Set the entry
+                            pItI() = pItJ();
+
+                            // Update maps for the point
+                            cMapI.mapSlave
+                            (
+                                coupleMap::POINT,
+                                pItI(), pItI.key()
+                            );
+
+                            cMapI.mapMaster
+                            (
+                                coupleMap::POINT,
+                                pItI.key(), pItI()
+                            );
+                        }
+
+                        foundMerge = true;
+                        break;
+                    }
+                }
+            }
+
+            if (foundMerge)
+            {
+                continue;
+            }
+
+            // Add a new unique point
+            label newPointIndex =
+            (
+                insertPoint
+                (
+                    pointI,
+                    meshI.oldPoints_[pItI.key()],
+                    labelList(1, -1)
+                )
+            );
+
+            // Set the entry
+            pItI() = newPointIndex;
+
+            // Update maps for the new point
+            cMapI.mapSlave(coupleMap::POINT, pItI(), pItI.key());
+            cMapI.mapMaster(coupleMap::POINT, pItI.key(), pItI());
+
+            if (debug > 2)
+            {
+                Pout<< " Map point: " << newPointIndex
+                    << " for point: " << pItI.key()
+                    << " on proc: " << procIndices_[pI]
+                    << endl;
+            }
+
+            // Add this point to the map.
+            map.addPoint(newPointIndex);
+        }
+    }
+
+    // Occassionally, inserted edges may already be present.
+    // Ensure that edges are not added twice.
+    if (!twoDMesh_)
+    {
+        forAll(facesToInsert, pI)
+        {
+            // Fetch reference to subMesh
+            const coupleMap& cMap = recvMeshes_[pI].map();
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            const Map<label>& procFaceMap = facesToInsert[pI];
+
+            forAllConstIter(Map<label>, procFaceMap, fIter)
+            {
+                const labelList& sfEdges = mesh.faceEdges_[fIter.key()];
+
+                forAll(sfEdges, edgeI)
+                {
+                    label seIndex = sfEdges[edgeI];
+
+                    if (edgesToInsert[pI][seIndex] != -1)
+                    {
+                        // Already mapped this edge. Move on.
+                        continue;
+                    }
+
+                    label cMe = cMap.findMaster(coupleMap::EDGE, seIndex);
+
+                    if (cMe > -1)
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found master edge: " << cMe
+                                << " :: " << edges_[cMe]
+                                << " for slave edge: " << seIndex
+                                << " :: " << mesh.edges_[seIndex]
+                                << " on proc: " << procIndices_[pI]
+                                << endl;
+                        }
+
+                        edgesToInsert[pI][seIndex] = cMe;
+                        edgesToConvert[pI][seIndex] = cMe;
+
+                        continue;
+                    }
+
+                    // Check for point-only coupling
+                    const edge& sEdge = mesh.edges_[seIndex];
+
+                    edge cEdge
+                    (
+                        cMap.findMaster(coupleMap::POINT, sEdge[0]),
+                        cMap.findMaster(coupleMap::POINT, sEdge[1])
+                    );
+
+                    if (cEdge[0] > -1 && cEdge[1] > -1)
+                    {
+                        label meIndex = -1;
+
+                        // Look at pointEdges info for a boundary edge
+                        const labelList& pEdges = pointEdges_[cEdge[0]];
+
+                        forAll(pEdges, edgeJ)
+                        {
+                            if (edges_[pEdges[edgeJ]] == cEdge)
+                            {
+                                if (whichEdgePatch(pEdges[edgeJ]) > -1)
+                                {
+                                    meIndex = pEdges[edgeJ];
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (meIndex > -1)
+                        {
+                            if (debug > 2)
+                            {
+                                Pout<< " Found master edge: " << meIndex
+                                    << " :: " << edges_[meIndex]
+                                    << " for slave edge: " << seIndex
+                                    << " :: " << mesh.edges_[seIndex]
+                                    << " on proc: " << procIndices_[pI]
+                                    << endl;
+                            }
+
+                            edgesToInsert[pI][seIndex] = meIndex;
+                            edgesToConvert[pI][seIndex] = meIndex;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Write out some debug info
+    if (debug > 2)
+    {
+        forAll(cellsToInsert, pI)
+        {
+            label procIndex = procIndices_[pI];
+
+            // Fetch reference to subMesh
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            // Define a convenience output macro
+#           define writeOutputVTK(fName, eMap, eType, insert)                  \
+            {                                                                  \
+                labelList entities(eMap.size());                               \
+                                                                               \
+                label nEnt = 0;                                                \
+                                                                               \
+                forAllConstIter(Map<label>, eMap, eIter)                       \
+                {                                                              \
+                    if (eIter() == -1 && insert)                               \
+                    {                                                          \
+                        entities[nEnt++] = eIter.key();                        \
+                    }                                                          \
+                    else                                                       \
+                    if (eIter() > -1 && !insert)                               \
+                    {                                                          \
+                        entities[nEnt++] = eIter.key();                        \
+                    }                                                          \
+                }                                                              \
+                                                                               \
+                entities.setSize(nEnt);                                        \
+                                                                               \
+                if (entities.size())                                           \
+                {                                                              \
+                    mesh.writeVTK                                              \
+                    (                                                          \
+                        word(fName) + '_'                                      \
+                      + Foam::name(mIndex) + '_'                               \
+                      + Foam::name(procIndex),                                 \
+                        entities,                                              \
+                        eType, false, true                                     \
+                    );                                                         \
+                }                                                              \
+            }
+
+            writeOutputVTK("edgesToConvert", edgesToConvert[pI], 1, false)
+            writeOutputVTK("facesToConvert", facesToConvert[pI], 2, false)
+            writeOutputVTK("pointsToConvert", pointsToInsert[pI], 0, false)
+            writeOutputVTK("pointsToInsert", pointsToInsert[pI], 0, true)
+            writeOutputVTK("edgesToInsert", edgesToInsert[pI], 1, true)
+            writeOutputVTK("facesToInsert", facesToInsert[pI], 2, true)
+            writeOutputVTK("cellsToInsert", cellsToInsert[pI], 3, false)
+        }
+    }
+
+    // Add edges to the mesh, noting that all
+    // required points have already been added.
+    forAll(edgesToInsert, pI)
+    {
+        // Fetch reference to subMesh
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        Map<label>& procEdgeMap = edgesToInsert[pI];
+
+        forAllIter(Map<label>, procEdgeMap, eIter)
+        {
+            // Skip if the edge is a conversion candidate
+            if (eIter() != -1)
+            {
+                continue;
+            }
+
+            const edge& sEdge = mesh.edges_[eIter.key()];
+
+            edge newEdge
+            (
+                cMap.findMaster(coupleMap::POINT, sEdge[0]),
+                cMap.findMaster(coupleMap::POINT, sEdge[1])
+            );
+
+            // Ensure that this edge hasn't been added before
+            label neIndex = -1;
+            bool foundDuplicate = false;
+
+            const List<objectMap>& addedEdges = map.addedEdgeList();
+
+            forAll(addedEdges, edgeI)
+            {
+                neIndex = addedEdges[edgeI].index();
+
+                if (edges_[neIndex] == newEdge)
+                {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+
+            if (foundDuplicate)
+            {
+                // Note the duplicate index for later
+                eIter() = neIndex;
+
+                continue;
+            }
+
+            // Insert edge with null edgeFaces for now.
+            // This can be corrected later.
+            eIter() =
+            (
+                insertEdge
+                (
+                    masterConvertEdgePatch[pI][eIter.key()],
+                    newEdge,
+                    labelList(0)
+                )
+            );
+
+            if (debug > 2)
+            {
+                Pout<< " Map edge: " << eIter() << "::" << newEdge
+                    << " for edge: " << eIter.key() << "::" << sEdge
+                    << endl;
+            }
+
+            // Add this edge to the map.
+            map.addEdge(eIter());
+        }
+    }
+
+    // Add faces to the mesh, noting that all required
+    // points and edges have already been added.
+    forAll(facesToInsert, pI)
+    {
+        // Fetch reference to subMesh and coupleMap
+        const coupleMap& cMapI = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& meshI = recvMeshes_[pI].subMesh();
+
+        Map<label>& procFaceMap = facesToInsert[pI];
+
+        forAllIter(Map<label>, procFaceMap, fI)
+        {
+            // Skip if the face is a conversion candidate
+            if (fI() != -1)
+            {
+                continue;
+            }
+
+            const face& sFaceI = meshI.faces_[fI.key()];
+            const labelList& sfEdges = meshI.faceEdges_[fI.key()];
+
+            // Configure new / comparison faces
+            face nF(sFaceI.size()), cF(sFaceI.size());
+            labelList nFaceEdges(sfEdges.size());
+
+            // Configure points from map
+            forAll(nF, pointI)
+            {
+                nF[pointI] =
+                (
+                    cMapI.findMaster
+                    (
+                        coupleMap::POINT,
+                        sFaceI[pointI]
+                    )
+                );
+            }
+
+            // This may be a face shared by two other processors.
+            // Ensure that duplicates are added only once.
+            label dupeOwnCell = -1;
+            bool foundDuplicate = false, foundInsertedDuplicate = false;
+
+            forAll(facesToInsert, pJ)
+            {
+                if (pJ == pI)
+                {
+                    continue;
+                }
+
+                // Fetch reference to subMesh and coupleMap
+                const coupleMap& cMapJ = recvMeshes_[pJ].map();
+                const dynamicTopoFvMesh& meshJ = recvMeshes_[pJ].subMesh();
+
+                const Map<label>& procFaceMapJ = facesToInsert[pJ];
+
+                forAllConstIter(Map<label>, procFaceMapJ, fJ)
+                {
+                    const face& sFaceJ = meshJ.faces_[fJ.key()];
+
+                    // Discard dissimilar face sizes
+                    if (sFaceJ.size() != cF.size())
+                    {
+                        continue;
+                    }
+
+                    // Configure points from map
+                    forAll(cF, pointI)
+                    {
+                        cF[pointI] =
+                        (
+                            cMapJ.findMaster
+                            (
+                                coupleMap::POINT,
+                                sFaceJ[pointI]
+                            )
+                        );
+                    }
+
+                    if (cF.size() == 3)
+                    {
+                        // Optimized triangular face comparison
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(nF[0], nF[1], nF[2]),
+                                triFace(cF[0], cF[1], cF[2])
+                            )
+                        )
+                        {
+                            foundDuplicate = true;
+                        }
+                    }
+                    else
+                    {
+                        // Regular face compare
+                        if (face::compare(nF, cF))
+                        {
+                            foundDuplicate = true;
+                        }
+                    }
+
+                    if (foundDuplicate)
+                    {
+                        // Record the owner for posterity
+                        dupeOwnCell =
+                        (
+                            cellsToInsert[pJ][meshJ.owner_[fJ.key()]]
+                        );
+
+                        // Was the duplicate face inserted before this?
+                        if (fJ() != -1)
+                        {
+                            // Note the duplicate index for later
+                            fI() = fJ();
+
+                            // If patch conversion entries were made,
+                            // remove them as well
+                            if
+                            (
+                                convertPatchPoints[pI].found(fJ.key())
+                             &&	convertPatchPoints[pJ].found(fI.key())
+                            )
+                            {
+                                convertPatchPoints[pI].erase(fJ.key());
+                                convertPatchPoints[pJ].erase(fI.key());
+                            }
+
+                            foundInsertedDuplicate = true;
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            // Face was inserted before, so don't insert again
+            if (foundInsertedDuplicate)
+            {
+                continue;
+            }
+
+            // Configure edges from edgesToInsert
+            forAll(sfEdges, edgeI)
+            {
+                label meIndex = -1;
+
+                // Configure with the appropriate edge
+                if (edgesToInsert[pI].found(sfEdges[edgeI]))
+                {
+                    meIndex = edgesToInsert[pI][sfEdges[edgeI]];
+                }
+
+                if (meIndex == -1)
+                {
+                    // Something is wrong here.
+                    Pout<< "  Could not find correspondence for slave edge: "
+                        << sfEdges[edgeI]
+                        << ":: " << meshI.edges_[sfEdges[edgeI]]
+                        << nl << " mIndex: " << mIndex
+                        << abort(FatalError);
+                }
+
+                nFaceEdges[edgeI] = meIndex;
+            }
+
+            // Determine patch, owner and neighbour for this face
+            label nPatch = -1, nOwner = -1, nNeighbour = -1;
+
+            const polyBoundaryMesh& slaveBoundary = meshI.boundaryMesh();
+
+            label sfPatch = meshI.whichPatch(fI.key());
+            label sFaceOwn = meshI.owner_[fI.key()];
+            label sFaceNei = meshI.neighbour_[fI.key()];
+
+            label mFaceOwn =
+            (
+                cellsToInsert[pI].found(sFaceOwn) ?
+                cellsToInsert[pI][sFaceOwn] : -1
+            );
+
+            label mFaceNei =
+            (
+                cellsToInsert[pI].found(sFaceNei) ?
+                cellsToInsert[pI][sFaceNei] : -1
+            );
+
+            // If a duplicate face was found, over-ride neighbour.
+            // Face-flipping will be taken care of automatically.
+            if (foundDuplicate)
+            {
+                mFaceNei = dupeOwnCell;
+            }
+
+            if (mFaceOwn != -1 && mFaceNei == -1)
+            {
+                // Boundary face already has correct orientation
+                nOwner = mFaceOwn;
+                nNeighbour = -1;
+
+                // Determine patch
+                nPatch = masterConvertFacePatch[pI][fI.key()];
+            }
+            else
+            if (mFaceOwn == -1 && mFaceNei != -1)
+            {
+                // Boundary face is inverted. Flip it
+                nF = nF.reverseFace();
+                nOwner = mFaceNei;
+                nNeighbour = -1;
+
+                // Determine patch
+                nPatch = masterConvertFacePatch[pI][fI.key()];
+            }
+            else
+            if (mFaceOwn != -1 && mFaceNei != -1)
+            {
+                // Interior face. Check if a flip is necessary.
+                if (mFaceNei < mFaceOwn)
+                {
+                    nF = nF.reverseFace();
+                    nOwner = mFaceNei;
+                    nNeighbour = mFaceOwn;
+                }
+                else
+                {
+                    nOwner = mFaceOwn;
+                    nNeighbour = mFaceNei;
+                }
+
+                nPatch = -1;
+            }
+            else
+            if (mFaceOwn == -1 && mFaceNei == -1)
+            {
+                // Something is wrong here.
+                Pout<< "Could not find correct owner / neighbour info: " << nl
+                    << " Face: " << nF << nl
+                    << " Owner: " << mFaceOwn << nl
+                    << " Neighbour: " << mFaceNei << nl
+                    << " - Slave Face: " << sFaceI << nl
+                    << " - Slave Patch: " << slaveBoundary[sfPatch].name() << nl
+                    << " - Slave Owner: " << sFaceOwn << nl
+                    << " - Slave Neighbour: " << sFaceNei << nl
+                    << abort(FatalError);
+            }
+
+            // Insert the new face
+            fI() =
+            (
+                insertFace
+                (
+                    nPatch,
+                    nF,
+                    nOwner,
+                    nNeighbour
+                )
+            );
+
+            // Add the faceEdges entry as well
+            faceEdges_.append(nFaceEdges);
+
+            // Size up edgeFaces for each edge
+            forAll(nFaceEdges, edgeI)
+            {
+                meshOps::sizeUpList
+                (
+                    fI(),
+                    edgeFaces_[nFaceEdges[edgeI]]
+                );
+            }
+
+            if (debug > 3)
+            {
+                Pout<< " Map face: " << fI() << "::" << nF
+                    << " Own: " << nOwner << " Nei: " << nNeighbour
+                    << " fE: " << nFaceEdges << nl
+                    << " for face: " << fI.key() << "::" << sFaceI
+                    << " Own: " << sFaceOwn << " Nei: " << sFaceNei
+                    << " fE: " << sfEdges
+                    << endl;
+            }
+
+            // Add this face to the map.
+            map.addFace(fI());
+
+            if (nPatch > -1 && getNeighbourProcessor(nPatch) == -1)
+            {
+                // Physical patch on subMesh.
+                //  - Set an invalid number so that
+                //    an entry is made in facesFromFaces,
+                //    while faceParents is empty.
+                setFaceMapping(fI(), labelList(1, -1));
+            }
+            else
+            {
+                // Interior / processor face
+                setFaceMapping(fI());
+            }
+
+            // Update cells
+            cells_[nOwner][nCellFaces[nOwner]++] = fI();
+
+            if (nNeighbour > -1)
+            {
+                cells_[nNeighbour][nCellFaces[nNeighbour]++] = fI();
+            }
+        }
+    }
+
+    // Loop through conversion faces
+    forAll(facesToConvert, pI)
+    {
+        // Fetch reference to subMesh
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        const Map<label>& procFaceMap = facesToConvert[pI];
+
+        forAllConstIter(Map<label>, procFaceMap, fIter)
+        {
+            label fIndex = fIter();
+
+            // Fetch the owner information
+            label mFaceOwn = owner_[fIndex];
+            label sFaceOwn = mesh.owner_[fIter.key()];
+            label newNeighbour = cellsToInsert[pI][sFaceOwn];
+
+            // Insert a new internal face.
+            // Orientation should be correct, because this is a boundary
+            // face converted to an interior, and adjacent to an added cell.
+            label newFaceIndex =
+            (
+                insertFace
+                (
+                    -1,
+                    face(faces_[fIndex]),
+                    mFaceOwn,
+                    newNeighbour
+                )
+            );
+
+            // Add the new faceEdges from the existing face. This may contain
+            // edges that need to be converted, but that will be done later.
+            faceEdges_.append(labelList(faceEdges_[fIndex]));
+
+            // Update map
+            map.addFace(newFaceIndex, labelList(1, fIndex));
+
+            // Set mapping information
+            setFaceMapping(newFaceIndex);
+
+            // Update the owner cell
+            meshOps::replaceLabel
+            (
+                fIndex,
+                newFaceIndex,
+                cells_[mFaceOwn]
+            );
+
+            // Update the neighbour cell
+            cells_[newNeighbour][nCellFaces[newNeighbour]++] = newFaceIndex;
+
+            // Replace edgeFaces with the new face index
+            const labelList& fEdges = faceEdges_[newFaceIndex];
+
+            forAll(fEdges, edgeI)
+            {
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex,
+                    edgeFaces_[fEdges[edgeI]]
+                );
+            }
+
+            // Remove the old boundary face
+            removeFace(fIndex);
+
+            // Update map
+            map.removeFace(fIndex);
+
+            // For 2D meshes, the boundary face gets converted
+            // to an interior one. Note the index for further operations.
+            if ((mIndex == fIndex) && twoDMesh_)
+            {
+                map.index() = newFaceIndex;
+            }
+        }
+    }
+
+    // Sequentially add any convert-patch operations
+    forAll(convertPatchPoints, pI)
+    {
+        // Fetch reference to maps / mesh
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        if (convertPatchPoints[pI].empty())
+        {
+            continue;
+        }
+
+        // Find the appropriate processor patch
+        // for patch conversion operations
+        label procPatch = -1;
+
+        for (label patchI = 0; patchI < mesh.nPatches_; patchI++)
+        {
+            label neiProc = mesh.getNeighbourProcessor(patchI);
+
+            if (neiProc == Pstream::myProcNo())
+            {
+                procPatch = patchI;
+                break;
+            }
+        }
+
+        if (procPatch == -1)
+        {
+            Pout<< " * * * insertCells() * * * " << nl
+                << " Could not find patch on slave processor: "
+                << procIndices_[pI] << nl
+                << " convertPatchPoints: " << convertPatchPoints[pI]
+                << abort(FatalError);
+        }
+
+        forAllConstIter(Map<Pair<point> >, convertPatchPoints[pI], fIter)
+        {
+            // Search slave mesh for faces
+            const point& newCentre = fIter().first();
+            const point& oldCentre = fIter().second();
+
+            label replaceFace = -1;
+
+            // Accumulate stats in case of failure
+            scalar minDist = GREAT;
+            vector minPoint = vector::zero;
+            DynamicList<label> checkedFaces;
+
+            if (debug > 2)
+            {
+                // Reserve for append
+                checkedFaces.setCapacity(50);
+            }
+
+            // Loop through all boundary faces,
+            // and compute / compare face centres
+            label sTot = mesh.faces_.size(), sInt = mesh.nOldInternalFaces_;
+
+            for (label faceI = sInt; faceI < sTot; faceI++)
+            {
+                const face& fCheck = mesh.faces_[faceI];
+
+                if (fCheck.empty())
+                {
+                    continue;
+                }
+
+                label pIndex = mesh.whichPatch(faceI);
+
+                if (mesh.getNeighbourProcessor(pIndex) == -1)
+                {
+                    continue;
+                }
+
+                // Compute face-centre
+                vector fC = fCheck.centre(mesh.points_);
+
+                // Compute tolerance
+                scalar tol = mag(mesh.points_[fCheck[0]] - fC);
+                scalar dist = mag(fC - newCentre);
+
+                if (dist < (1e-4 * tol))
+                {
+                    replaceFace = faceI;
+                    break;
+                }
+                else
+                if (dist < minDist)
+                {
+                    minPoint = fC;
+                    minDist = dist;
+
+                    if (debug > 2)
+                    {
+                        checkedFaces.append(faceI);
+                    }
+                }
+            }
+
+            // Ensure that the face was found
+            if (replaceFace == -1)
+            {
+                mesh.writeVTK
+                (
+                    "checkedFaces_"
+                  + Foam::name(fIter.key()),
+                    checkedFaces,
+                    2, false, true
+                );
+
+                Pout<< " * * * insertCells() * * * " << nl
+                    << " Convert patch Op failed." << nl
+                    << " Face: " << fIter.key() << nl
+                    << " minPoint: " << minPoint << nl
+                    << " minDistance: " << minDist << nl
+                    << " newCentre: " << newCentre << nl
+                    << " oldCentre: " << oldCentre << nl
+                    << abort(FatalError);
+            }
+
+            // Obtain a copy before adding the new face,
+            // since the reference might become
+            // invalid during list resizing.
+            face newFace = mesh.faces_[replaceFace];
+            label newOwn = mesh.owner_[replaceFace];
+            labelList newFaceEdges = mesh.faceEdges_[replaceFace];
+
+            label newFaceIndex =
+            (
+                mesh.insertFace
+                (
+                    procPatch,
+                    newFace,
+                    newOwn,
+                    -1
+                )
+            );
+
+            // Add a faceEdges entry as well.
+            // Edges don't have to change, since they're
+            // all on the boundary anyway.
+            mesh.faceEdges_.append(newFaceEdges);
+
+            // changeMap update for the new face is not necessary,
+            // since it is on the slave subMesh
+
+            // Set mapping information
+            mesh.setFaceMapping(newFaceIndex);
+
+            meshOps::replaceLabel
+            (
+                replaceFace,
+                newFaceIndex,
+                mesh.cells_[newOwn]
+            );
+
+            // Correct edgeFaces with the new face label.
+            forAll(newFaceEdges, edgeI)
+            {
+                meshOps::replaceLabel
+                (
+                    replaceFace,
+                    newFaceIndex,
+                    mesh.edgeFaces_[newFaceEdges[edgeI]]
+                );
+            }
+
+            if (debug > 3)
+            {
+                Pout<< " Pushing CONVERT_PATCH for face: " << replaceFace
+                    << " :: " << mesh.faces_[replaceFace] << nl
+                    << " with new point: " << fIter().first()
+                    << " and old point: " << fIter().second()
+                    << " on proc: " << procIndices_[pI]
+                    << endl;
+            }
+
+            // Finally remove the face
+            mesh.removeFace(replaceFace);
+
+            cMap.pushOperation
+            (
+                replaceFace,
+                coupleMap::CONVERT_PATCH,
+                fIter().first(),
+                fIter().second()
+            );
+        }
+    }
+
+    // Loop through conversion edges
+    forAll(edgesToConvert, pI)
+    {
+        // Fetch references
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        const Map<label>& procEdgeMap = edgesToConvert[pI];
+
+        // Loop through conversion edges
+        forAllConstIter(Map<label>, procEdgeMap, eIter)
+        {
+            label eIndex = eIter(), physPatch = -1;
+            bool allInterior = true, keepEdge = true;
+
+            if (eIndex < 0)
+            {
+                // Not a conversion edge. Search added edge list for index
+                eIndex = edgesToInsert[pI][eIter.key()];
+
+                if (eIndex < 0)
+                {
+                    // Something's wrong
+                    Pout<< " Edge: " << eIter.key()
+                        << " :: " << mesh.edges_[eIter.key()]
+                        << " was never inserted."
+                        << abort(FatalError);
+                }
+            }
+
+            const labelList& eFaces = edgeFaces_[eIndex];
+
+            if (eFaces.size())
+            {
+                forAll(eFaces, faceI)
+                {
+                    if (whichPatch(eFaces[faceI]) > -1)
+                    {
+                        allInterior = false;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                // Edge was deleted before, so skip it
+                allInterior = false;
+            }
+
+            if (allInterior)
+            {
+                physPatch = -1;
+                keepEdge = false;
+            }
+            else
+            if (eFaces.size())
+            {
+                // Check if patches need to be switched
+                label edgePatch = whichEdgePatch(eIndex);
+
+                // Is this edge on a processor patch?
+                bool edgeOnProc = (getNeighbourProcessor(edgePatch) > -1);
+
+                if (edgeOnProc)
+                {
+                    bool foundProc = false;
+
+                    forAll(eFaces, faceI)
+                    {
+                        label fPatch = whichPatch(eFaces[faceI]);
+
+                        if (fPatch == -1)
+                        {
+                            continue;
+                        }
+
+                        if (getNeighbourProcessor(fPatch) == -1)
+                        {
+                            // Note physical patch for later
+                            physPatch = fPatch;
+                        }
+                        else
+                        {
+                            // Still on a processor patch.
+                            foundProc = true;
+                            break;
+                        }
+                    }
+
+                    if (foundProc)
+                    {
+                        // Reset physPatch
+                        physPatch = -1;
+                    }
+                }
+
+                if (edgeOnProc && physPatch > -1)
+                {
+                    // Edge needs to be moved to another patch
+                    keepEdge = false;
+                }
+                else
+                if ((mIndex == eIndex) && !twoDMesh_ && map.index() == -1)
+                {
+                    // Keep the edge, and note index for later
+                    keepEdge = true;
+                    map.index() = eIndex;
+                }
+            }
+
+            if (keepEdge)
+            {
+                continue;
+            }
+
+            // This edge needs to be converted to interior / other patch
+            label newEdgeIndex =
+            (
+                insertEdge
+                (
+                    physPatch,
+                    edge(edges_[eIndex]),
+                    labelList(edgeFaces_[eIndex])
+                )
+            );
+
+            // Update map
+            map.addEdge(newEdgeIndex, labelList(1, eIndex));
+
+            // Update faceEdges information for all connected faces
+            const labelList& neFaces = edgeFaces_[newEdgeIndex];
+
+            forAll(neFaces, faceI)
+            {
+                meshOps::replaceLabel
+                (
+                    eIndex,
+                    newEdgeIndex,
+                    faceEdges_[neFaces[faceI]]
+                );
+            }
+
+            // Remove the old boundary edge
+            removeEdge(eIndex);
+
+            // Update map
+            map.removeEdge(eIndex);
+
+            // For 3D meshes, the boundary edge gets converted
+            // to an interior one. Note the index for further operations.
+            if ((mIndex == eIndex) && !twoDMesh_)
+            {
+                map.index() = newEdgeIndex;
+            }
+
+            // Replace the entry in edgesToInsert
+            edgesToInsert[pI][eIter.key()] = newEdgeIndex;
+        }
+    }
+
+    List<changeMap> slaveMaps(procIndices_.size());
+
+    // Loop through all processors, and remove cells
+    forAll(cellsToInsert, pI)
+    {
+        const Map<label>& procCellMap = cellsToInsert[pI];
+
+        if (procCellMap.empty())
+        {
+            // Set type to something recognizable
+            slaveMaps[pI].type() = -7;
+
+            continue;
+        }
+
+        // Prepare a list of cells
+        const labelList cellsToRemove = procCellMap.toc();
+
+        // Fetch non-const reference to subMesh
+        dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        // Now remove cells for this processor
+        slaveMaps[pI] =
+        (
+            mesh.removeCells
+            (
+                cellsToRemove,
+                slaveConvertPatch[pI],
+                "rc_" + Foam::name(mIndex)
+            )
+        );
+    }
+
+    // Now map entities from the removeCells operation
+    forAll(slaveMaps, pI)
+    {
+        const changeMap& slaveMap = slaveMaps[pI];
+
+        // Skip empty entities
+        if (slaveMap.type() == -7)
+        {
+            continue;
+        }
+
+        // Fetch references
+        const coupleMap& cMap = recvMeshes_[pI].map();
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        // Map faces from patches.
+        const Map<label>& procFaceMap = facesToInsert[pI];
+
+        // Check removed faces
+        const labelList& rsfList = slaveMap.removedFaceList();
+
+        forAll(rsfList, indexI)
+        {
+            label sfIndex = rsfList[indexI], mfIndex = -1;
+
+            // Does an entry exist?
+            mfIndex = cMap.findMaster(coupleMap::FACE, sfIndex);
+
+            if (mfIndex > -1)
+            {
+                if (debug > 2)
+                {
+                    Pout<< " Removing map for master face: "
+                        << mfIndex << " :: " << faces_[mfIndex]
+                        << " Master map: "
+                        << cMap.findSlave(coupleMap::FACE, mfIndex)
+                        << " and slave face: " << sfIndex
+                        << " on proc: " << procIndices_[pI]
+                        << endl;
+                }
+
+                cMap.removeSlave(coupleMap::FACE, sfIndex);
+                cMap.removeMaster(coupleMap::FACE, mfIndex);
+            }
+        }
+
+        // Check added faces
+        const List<objectMap>& asfList = slaveMap.addedFaceList();
+
+        forAll(asfList, indexI)
+        {
+            label sfIndex = asfList[indexI].index(), mfIndex = -1;
+
+            if (mesh.whichPatch(sfIndex) == slaveConvertPatch[pI])
+            {
+                // Configure a comparison face
+                face cFace(mesh.faces_[sfIndex]);
+
+                forAll(cFace, pointI)
+                {
+                    cFace[pointI] =
+                    (
+                        cMap.findMaster
+                        (
+                            coupleMap::POINT,
+                            cFace[pointI]
+                        )
+                    );
+                }
+
+                bool foundMatch = false;
+
+                forAllConstIter(Map<label>, procFaceMap, fIter)
+                {
+                    const face& mFace = faces_[fIter()];
+
+                    // Discard dissimilar face sizes
+                    if (mFace.size() != cFace.size())
+                    {
+                        continue;
+                    }
+
+                    if (cFace.size() == 3)
+                    {
+                        // Optimized triangular face comparison
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(mFace[0], mFace[1], mFace[2]),
+                                triFace(cFace[0], cFace[1], cFace[2])
+                            )
+                        )
+                        {
+                            mfIndex = fIter();
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        // Regular face compare
+                        if (face::compare(mFace, cFace))
+                        {
+                            mfIndex = fIter();
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (foundMatch)
+                {
+                    if (debug > 2)
+                    {
+                        Pout<< " Found master face: " << mfIndex
+                            << " :: " << faces_[mfIndex]
+                            << " for slave face: " << sfIndex
+                            << " :: " << mesh.faces_[sfIndex]
+                            << " on proc: " << procIndices_[pI]
+                            << endl;
+                    }
+
+                    // Update maps for the new face
+                    cMap.mapSlave(coupleMap::FACE, mfIndex, sfIndex);
+                    cMap.mapMaster(coupleMap::FACE, sfIndex, mfIndex);
+                }
+                else
+                {
+                    // Something is wrong here.
+                    Pout<< " Could not find master face for: " << nl
+                        << "  Slave face: " << sfIndex
+                        << "  :: " << mesh.faces_[sfIndex] << nl
+                        << "  cFace: " << cFace << nl
+                        << "  on proc: " << procIndices_[pI] << nl
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        // Map edges for 3D meshes
+        if (!twoDMesh_)
+        {
+            // Map edges from patches.
+            const Map<label>& procEdgeMap = edgesToInsert[pI];
+
+            // Check removed edges
+            const labelList& rseList = slaveMap.removedEdgeList();
+
+            forAll(rseList, indexI)
+            {
+                label seIndex = rseList[indexI], meIndex = -1;
+
+                // Does an entry exist?
+                meIndex = cMap.findMaster(coupleMap::EDGE, seIndex);
+
+                if (meIndex > -1)
+                {
+                    if (debug > 2)
+                    {
+                        Pout<< " Removing map for master edge: "
+                            << meIndex << " :: " << edges_[meIndex]
+                            << " Master map: "
+                            << cMap.findSlave(coupleMap::EDGE, meIndex)
+                            << " and slave edge: " << seIndex
+                            << " on proc: " << procIndices_[pI]
+                            << endl;
+                    }
+
+                    cMap.removeSlave(coupleMap::EDGE, seIndex);
+                    cMap.removeMaster(coupleMap::EDGE, meIndex);
+                }
+            }
+
+            // Check added edges
+            const List<objectMap>& aseList = slaveMap.addedEdgeList();
+
+            forAll(aseList, indexI)
+            {
+                label seIndex = aseList[indexI].index(), meIndex = -1;
+
+                if (mesh.whichEdgePatch(seIndex) == slaveConvertPatch[pI])
+                {
+                    // Configure a comparison edge
+                    edge cEdge(mesh.edges_[seIndex]);
+
+                    cEdge[0] = cMap.findMaster(coupleMap::POINT, cEdge[0]);
+                    cEdge[1] = cMap.findMaster(coupleMap::POINT, cEdge[1]);
+
+                    bool foundMatch = false;
+
+                    forAllConstIter(Map<label>, procEdgeMap, eIter)
+                    {
+                        const edge& mEdge = edges_[eIter()];
+
+                        if (mEdge == cEdge)
+                        {
+                            meIndex = eIter();
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+
+                    if (foundMatch)
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found master edge: " << meIndex
+                                << " :: " << edges_[meIndex]
+                                << " for slave edge: " << seIndex
+                                << " :: " << mesh.edges_[seIndex]
+                                << " on proc: " << procIndices_[pI]
+                                << endl;
+                        }
+
+                        // Update maps for the new edge
+                        cMap.mapSlave(coupleMap::EDGE, meIndex, seIndex);
+                        cMap.mapMaster(coupleMap::EDGE, seIndex, meIndex);
+                    }
+                    else
+                    {
+                        // Something is wrong here.
+                        Pout<< " Could not find master edge for: " << nl
+                            << "  Slave edge: " << seIndex
+                            << "  :: " << mesh.edges_[seIndex] << nl
+                            << "  cEdge: " << cEdge << nl
+                            << " on proc: " << procIndices_[pI] << nl
+                            << abort(FatalError);
+                    }
+                }
+            }
+        }
+
+        // Check removed points
+        const labelList& rspList = slaveMap.removedPointList();
+
+        forAll(rspList, indexI)
+        {
+            label spIndex = rspList[indexI], mpIndex = -1;
+
+            // Does an entry exist?
+            mpIndex = cMap.findMaster(coupleMap::POINT, spIndex);
+
+            if (mpIndex > -1)
+            {
+                if (debug > 2)
+                {
+                    Pout<< " Removing map for master point: " << mpIndex
+                        << " :: new: " << points_[mpIndex]
+                        << " :: old: " << oldPoints_[mpIndex] << nl
+                        << " Master point map: "
+                        << cMap.findSlave(coupleMap::POINT, mpIndex)
+                        << " and slave point: " << spIndex
+                        << " on proc: " << procIndices_[pI]
+                        << endl;
+                }
+
+                cMap.removeSlave(coupleMap::POINT, spIndex);
+                cMap.removeMaster(coupleMap::POINT, mpIndex);
+            }
+        }
+    }
+
+    // Write out cells for debug, if necessary
+    if (debug > 2 || map.index() < 0)
+    {
+        const List<objectMap>& acList = map.addedCellList();
+
+        labelList addedCells(acList.size(), -1);
+
+        forAll(acList, indexI)
+        {
+            addedCells[indexI] = acList[indexI].index();
+        }
+
+        // Write it out
+        writeVTK
+        (
+            "insertCells(" + Foam::name(mIndex) + ')',
+            addedCells, 3, false, true
+        );
+    }
+
+    // Set mapping information for any added faces
+    const List<objectMap>& afList = map.addedFaceList();
+
+    forAll(afList, indexI)
+    {
+        label mfIndex = afList[indexI].index();
+        label patch = whichPatch(mfIndex);
+        label neiProc = getNeighbourProcessor(patch);
+
+        // Disregard non-processor faces for coupled mapping
+        if (neiProc == -1)
+        {
+            continue;
+        }
+
+        // Update couple maps, if necessary
+        const face& mFace = faces_[mfIndex];
+
+        forAll(procIndices_, pI)
+        {
+            // Skip face if not on this processor
+            if (neiProc != procIndices_[pI])
+            {
+                continue;
+            }
+
+            const coupleMap& cMap = recvMeshes_[pI].map();
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            // Configure a comparison face
+            face cFace(mFace);
+
+            forAll(cFace, pointI)
+            {
+                cFace[pointI] =
+                (
+                    cMap.findSlave
+                    (
+                        coupleMap::POINT,
+                        cFace[pointI]
+                    )
+                );
+            }
+
+            // Ensure all points are found
+            if (findIndex(cFace, -1) > -1)
+            {
+                continue;
+            }
+
+            // Loop through boundary faces on slave and look for a match
+            label sTot = mesh.faces_.size(), sInt = mesh.nOldInternalFaces_;
+
+            label sfIndex = -1;
+
+            for (label sfI = sInt; sfI < sTot; sfI++)
+            {
+                const face& sFace = mesh.faces_[sfI];
+
+                if (sFace.empty())
+                {
+                    continue;
+                }
+
+                label pIndex = mesh.whichPatch(sfI);
+
+                if (mesh.getNeighbourProcessor(pIndex) == -1)
+                {
+                    continue;
+                }
+
+                if (twoDMesh_)
+                {
+                    if (face::compare(cFace, sFace))
+                    {
+                        sfIndex = sfI;
+                    }
+                }
+                else
+                {
+                    if
+                    (
+                        triFace::compare
+                        (
+                            triFace(cFace[0], cFace[1], cFace[2]),
+                            triFace(sFace[0], sFace[1], sFace[2])
+                        )
+                    )
+                    {
+                        sfIndex = sfI;
+                    }
+                }
+
+                // Break out if we're done
+                if (sfIndex > -1)
+                {
+                    if (debug > 2)
+                    {
+                        Pout<< " Matched master face: " << mfIndex
+                            << " :: " << mFace
+                            << " with slave: " << sfIndex
+                            << " :: " << sFace
+                            << " on proc: " << procIndices_[pI]
+                            << endl;
+                    }
+
+                    // Found the slave. Add a map entry
+                    cMap.mapSlave
+                    (
+                        coupleMap::FACE,
+                        mfIndex,
+                        sfIndex
+                    );
+
+                    cMap.mapMaster
+                    (
+                        coupleMap::FACE,
+                        sfIndex,
+                        mfIndex
+                    );
+
+                    break;
+                }
+            }
+
+            if (sfIndex == -1)
+            {
+                Pout<< " Failed match for master face: " << mfIndex
+                    << " :: " << mFace
+                    << " on proc: " << procIndices_[pI]
+                    << abort(FatalError);
+            }
+
+            if (twoDMesh_)
+            {
+                continue;
+            }
+
+            // Map edges on this face as well
+            const labelList& mfEdges = faceEdges_[mfIndex];
+            const labelList& sfEdges = mesh.faceEdges_[sfIndex];
+
+            forAll(mfEdges, edgeI)
+            {
+                label meIndex = mfEdges[edgeI];
+                const edge& mEdge = edges_[meIndex];
+
+                // Configure a comparison edge
+                edge cEdge
+                (
+                    cMap.findSlave(coupleMap::POINT, mEdge[0]),
+                    cMap.findSlave(coupleMap::POINT, mEdge[1])
+                );
+
+                forAll(sfEdges, edgeJ)
+                {
+                    label seIndex = sfEdges[edgeJ];
+                    const edge& sEdge = mesh.edges_[seIndex];
+
+                    if (cEdge == sEdge)
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Matched master edge: " << meIndex
+                                << " :: " << mEdge
+                                << " with slave: " << seIndex
+                                << " :: " << sEdge
+                                << " on proc: " << procIndices_[pI]
+                                << endl;
+                        }
+
+                        // Found the slave. Add a map entry
+                        cMap.mapSlave
+                        (
+                            coupleMap::EDGE,
+                            meIndex,
+                            seIndex
+                        );
+
+                        cMap.mapMaster
+                        (
+                            coupleMap::EDGE,
+                            seIndex,
+                            meIndex
+                        );
+
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+
+// Remove the specified cells from the mesh,
+// and add internal faces/edges to the specified patch
+// - Returns a changeMap with a type specifying:
+//     1: Operation was successful
+//    -1: Operation failed
+// - checkOnly performs a feasibility check and returns without modifications.
+const changeMap dynamicTopoFvMesh::removeCells
+(
+    const labelList& cList,
+    const label patch,
+    const word& rcN,
+    bool checkOnly
+)
+{
+    if (cList.empty() || patch < 0)
+    {
+        if (cList.size())
+        {
+            writeVTK("removeCellsFailed_" + rcN, cList, 3, false, true);
+        }
+
+        FatalErrorIn
+        (
+            "const changeMap dynamicTopoFvMesh::removeCells"
+            "(const labelList&, const label, const word&, bool)"
+        )
+            << " Wrong arguments. " << nl
+            << " cList: " << cList << nl
+            << " patch: " << patch << nl
+            << abort(FatalError);
+    }
+
+    changeMap map;
+
+    labelHashSet pointsToRemove, edgesToRemove, facesToRemove;
+    Map<label> facesToConvert, edgesToConvert;
+
+    // First loop through all cells and accumulate
+    // a set of faces to be removed/converted.
+    forAll(cList, cellI)
+    {
+        const cell& cellToCheck = cells_[cList[cellI]];
+
+        forAll(cellToCheck, faceI)
+        {
+            label own = owner_[cellToCheck[faceI]];
+            label nei = neighbour_[cellToCheck[faceI]];
+
+            if (nei == -1)
+            {
+                if (!facesToRemove.found(cellToCheck[faceI]))
+                {
+                    facesToRemove.insert(cellToCheck[faceI]);
+                }
+            }
+            else
+            if
+            (
+                (findIndex(cList, own) != -1) &&
+                (findIndex(cList, nei) != -1)
+            )
+            {
+                if (!facesToRemove.found(cellToCheck[faceI]))
+                {
+                    facesToRemove.insert(cellToCheck[faceI]);
+                }
+            }
+            else
+            {
+                facesToConvert.set(cellToCheck[faceI], -1);
+            }
+        }
+    }
+
+    // Add all edges as candidates for conversion.
+    // Some of these will be removed altogether.
+    forAllConstIter(labelHashSet, facesToRemove, fIter)
+    {
+        const labelList& fEdges = faceEdges_[fIter.key()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (whichEdgePatch(fEdges[edgeI]) == patch)
+            {
+                // Make an identical map
+                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
+            }
+            else
+            {
+                edgesToConvert.set(fEdges[edgeI], -1);
+            }
+
+            if (twoDMesh_)
+            {
+                // Add all points as candidates for removal.
+                // Some (or all) of these will be weeded out.
+                const edge& eCheck = edges_[fEdges[edgeI]];
+
+                pointsToRemove.set(eCheck[0]);
+                pointsToRemove.set(eCheck[1]);
+            }
+        }
+    }
+
+    forAllConstIter(Map<label>, facesToConvert, fIter)
+    {
+        const labelList& fEdges = faceEdges_[fIter.key()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (whichEdgePatch(fEdges[edgeI]) == patch)
+            {
+                // Make an identical map
+                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
+            }
+            else
+            {
+                edgesToConvert.set(fEdges[edgeI], -1);
+            }
+        }
+    }
+
+    // Build a list of edges to be removed.
+    forAllConstIter(Map<label>, edgesToConvert, eIter)
+    {
+        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+        bool allRemove = true;
+
+        forAll(eFaces, faceI)
+        {
+            if (!facesToRemove.found(eFaces[faceI]))
+            {
+                allRemove = false;
+                break;
+            }
+        }
+
+        if (allRemove)
+        {
+            if (!edgesToRemove.found(eIter.key()))
+            {
+                edgesToRemove.insert(eIter.key());
+            }
+        }
+    }
+
+    // Weed-out the conversion list.
+    forAllConstIter(labelHashSet, edgesToRemove, eIter)
+    {
+        edgesToConvert.erase(eIter.key());
+    }
+
+    // Build a set of points to be removed.
+    if (twoDMesh_)
+    {
+        forAllConstIter(Map<label>, edgesToConvert, eIter)
+        {
+            const edge& eCheck = edges_[eIter.key()];
+
+            if (pointsToRemove.found(eCheck[0]))
+            {
+                pointsToRemove.erase(eCheck[0]);
+            }
+
+            if (pointsToRemove.found(eCheck[1]))
+            {
+                pointsToRemove.erase(eCheck[1]);
+            }
+        }
+    }
+    else
+    {
+        forAllConstIter(labelHashSet, edgesToRemove, eIter)
+        {
+            const edge& edgeToCheck = edges_[eIter.key()];
+
+            forAll(edgeToCheck, pointI)
+            {
+                const labelList& pEdges = pointEdges_[edgeToCheck[pointI]];
+
+                bool allRemove = true;
+
+                forAll(pEdges, edgeI)
+                {
+                    if (!edgesToRemove.found(pEdges[edgeI]))
+                    {
+                        allRemove = false;
+                        break;
+                    }
+                }
+
+                if (allRemove)
+                {
+                    if (!pointsToRemove.found(edgeToCheck[pointI]))
+                    {
+                        pointsToRemove.insert(edgeToCheck[pointI]);
+                    }
+                }
+            }
+        }
+    }
+
+    forAllIter(Map<label>, edgesToConvert, eIter)
+    {
+        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+        label nConvFaces = 0;
+
+        forAll(eFaces, faceI)
+        {
+            if (facesToConvert.found(eFaces[faceI]))
+            {
+                nConvFaces++;
+            }
+        }
+
+        if (nConvFaces > 2)
+        {
+            Pout<< "Invalid conversion. Bailing out." << endl;
+            return map;
+        }
+    }
+
+    // Are we only performing checks?
+    if (checkOnly)
+    {
+        // Make necessary map entries
+        forAllConstIter(Map<label>, facesToConvert, fIter)
+        {
+            map.removeFace(fIter.key());
+        }
+
+        forAllConstIter(Map<label>, edgesToConvert, eIter)
+        {
+            map.removeEdge(eIter.key());
+        }
+
+        forAllConstIter(labelHashSet, facesToRemove, fIter)
+        {
+            map.removeFace(fIter.key());
+        }
+
+        forAllConstIter(labelHashSet, edgesToRemove, eIter)
+        {
+            map.removeEdge(eIter.key());
+        }
+
+        forAllConstIter(labelHashSet, pointsToRemove, pIter)
+        {
+            map.removePoint(pIter.key());
+        }
+
+        forAll(cList, cellI)
+        {
+            map.removeCell(cList[cellI]);
+        }
+
+        // Specify that the operation was successful
+        map.type() = 1;
+
+        return map;
+    }
+
+    // Perform a few debug calls before modifications
+    if (debug > 1)
+    {
+        Pout<< nl << nl
+            << " Removing cell(s): " << cList
+            << " and adding internal faces / edges to patch: "
+            << boundaryMesh()[patch].name()
+            << endl;
+    }
+
+    // Write out candidates for post-processing
+    if (debug > 2)
+    {
+        writeVTK("pointsToRemove_" + rcN, pointsToRemove.toc(), 0, false, true);
+        writeVTK("edgesToRemove_" + rcN, edgesToRemove.toc(), 1, false, true);
+        writeVTK("facesToRemove_" + rcN, facesToRemove.toc(), 2, false, true);
+        writeVTK("cellsToRemove_" + rcN, cList, 3, false, true);
+        writeVTK("edgesToConvert_" + rcN, edgesToConvert.toc(), 1, false, true);
+        writeVTK("facesToConvert_" + rcN, facesToConvert.toc(), 2, false, true);
+    }
+
+    // Loop through all faces for conversion, check orientation
+    // and create new faces in their place.
+    forAllIter(Map<label>, facesToConvert, fIter)
+    {
+        // Check if this internal face is oriented properly.
+        face newFace;
+        label newOwner = -1;
+        labelList fEdges = faceEdges_[fIter.key()];
+
+        if (findIndex(cList, neighbour_[fIter.key()]) != -1)
+        {
+            // Orientation is correct
+            newFace = faces_[fIter.key()];
+            newOwner = owner_[fIter.key()];
+        }
+        else
+        if (findIndex(cList, owner_[fIter.key()]) != -1)
+        {
+            // Face is to be reversed.
+            newFace = faces_[fIter.key()].reverseFace();
+            newOwner = neighbour_[fIter.key()];
+
+            setFlip(fIter.key());
+        }
+        else
+        {
+            // Something's terribly wrong
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::removeCells\n"
+                "(\n"
+                "    const labelList& cList,\n"
+                "    const label patch,\n"
+                "    const word& rcN,\n"
+                "    bool checkOnly\n"
+                ")\n"
+            )
+                << nl << " Invalid mesh. "
+                << abort(FatalError);
+        }
+
+        // Insert the reconfigured face at the boundary.
+        fIter() =
+        (
+            insertFace
+            (
+                patch,
+                newFace,
+                newOwner,
+                -1
+            )
+        );
+
+        // Add the faceEdges entry.
+        // Edges will be corrected later.
+        faceEdges_.append(fEdges);
+
+        // Add this face to the map.
+        map.addFace(fIter());
+
+        // Set mapping information
+        //  - But where to map from?
+        setFaceMapping(fIter());
+
+        // Replace cell with the new face label
+        meshOps::replaceLabel
+        (
+            fIter.key(),
+            fIter(),
+            cells_[newOwner]
+        );
+
+        // Remove the internal face.
+        removeFace(fIter.key());
+
+        // Update map
+        map.removeFace(fIter.key());
+    }
+
+    // Create a new edge for each converted edge
+    forAllIter(Map<label>, edgesToConvert, eIter)
+    {
+        if (eIter() == -1)
+        {
+            // Create copies before appending.
+            edge newEdge = edges_[eIter.key()];
+            labelList eFaces = edgeFaces_[eIter.key()];
+
+            eIter() =
+            (
+                insertEdge
+                (
+                    patch,
+                    newEdge,
+                    eFaces
+                )
+            );
+
+            // Add this edge to the map.
+            map.addEdge(eIter());
+
+            // Remove the edge
+            removeEdge(eIter.key());
+
+            // Update map
+            map.removeEdge(eIter.key());
+        }
+    }
+
+    // Loop through all faces for conversion, and replace edgeFaces.
+    forAllConstIter(Map<label>, facesToConvert, fIter)
+    {
+        // Make a copy, because this list is going to
+        // be modified within this loop.
+        labelList fEdges = faceEdges_[fIter()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (edgesToConvert.found(fEdges[edgeI]))
+            {
+                meshOps::replaceLabel
+                (
+                    fIter.key(),
+                    fIter(),
+                    edgeFaces_[edgesToConvert[fEdges[edgeI]]]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fEdges[edgeI],
+                    edgesToConvert[fEdges[edgeI]],
+                    faceEdges_[fIter()]
+                );
+            }
+        }
+    }
+
+    // Loop through all edges for conversion, and size-down edgeFaces.
+    forAllConstIter(Map<label>, edgesToConvert, eIter)
+    {
+        // Make a copy, because this list is going to
+        // be modified within this loop.
+        labelList eFaces = edgeFaces_[eIter()];
+
+        forAll(eFaces, faceI)
+        {
+            if (facesToRemove.found(eFaces[faceI]))
+            {
+                meshOps::sizeDownList
+                (
+                    eFaces[faceI],
+                    edgeFaces_[eIter()]
+                );
+            }
+
+            // Replace old edges with new ones.
+            labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+            forAll(fEdges, edgeI)
+            {
+                if (edgesToConvert.found(fEdges[edgeI]))
+                {
+                    fEdges[edgeI] = edgesToConvert[fEdges[edgeI]];
+                }
+            }
+        }
+    }
+
+    // Remove unwanted faces
+    forAllConstIter(labelHashSet, facesToRemove, fIter)
+    {
+        removeFace(fIter.key());
+
+        // Update map
+        map.removeFace(fIter.key());
+    }
+
+    // Remove unwanted edges
+    forAllConstIter(labelHashSet, edgesToRemove, eIter)
+    {
+        removeEdge(eIter.key());
+
+        // Update map
+        map.removeEdge(eIter.key());
+    }
+
+    // Remove unwanted points
+    forAllConstIter(labelHashSet, pointsToRemove, pIter)
+    {
+        removePoint(pIter.key());
+
+        // Update map
+        map.removePoint(pIter.key());
+    }
+
+    // Remove all cells
+    forAll(cList, cellI)
+    {
+        removeCell(cList[cellI]);
+
+        // Update map
+        map.removeCell(cList[cellI]);
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    return map;
+}
+
+
+// Handle topology changes for coupled patches
+void dynamicTopoFvMesh::handleCoupledPatches
+(
+    labelHashSet& entities
+)
+{
+    // Initialize coupled patch connectivity for topology modifications.
+    initCoupledConnectivity(this);
+
+    if (patchCoupling_.empty() && procIndices_.empty())
+    {
+        return;
+    }
+
+    // Move coupled subMeshes
+    moveCoupledSubMeshes();
+
+    // Exchange length-scale buffers across processors.
+    exchangeLengthBuffers();
+
+    if (debug)
+    {
+        // Check coupled-patch sizes first.
+        forAll(patchCoupling_, patchI)
+        {
+            if (patchCoupling_(patchI))
+            {
+                const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                label mSize = patchSizes_[cMap.masterIndex()];
+                label sSize = patchSizes_[cMap.slaveIndex()];
+
+                if (mSize != sSize)
+                {
+                    Pout<< "Coupled patch-count is inconsistent." << nl
+                        << " Master Patch: " << cMap.masterIndex()
+                        << " Count: " << mSize << nl
+                        << " Slave Patch: " << cMap.slaveIndex()
+                        << " Count: " << sSize
+                        << endl;
+
+                    FatalErrorIn
+                    (
+                        "void dynamicTopoFvMesh::handleCoupledPatches()"
+                    )
+                        << " Failures were found in connectivity"
+                        << " prior to coupled topo-changes."
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        Info<< "Handling coupled patches...";
+    }
+
+    if (Pstream::parRun())
+    {
+        // Calculate mapping offsets
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        // Determine number of physical (non-processor) patches
+        label nPhysical = 0;
+
+        forAll(boundary, patchI)
+        {
+            if (isA<processorPolyPatch>(boundary[patchI]))
+            {
+                continue;
+            }
+
+            nPhysical++;
+        }
+
+        // Fetch number of processors
+        label nProcs = procIndices_.size();
+
+        // Allocate cell, face and patch offsets
+        labelList cellSizes(nProcs, 0), cellStarts(nProcs, 0);
+        labelList faceSizes(nProcs, 0), faceStarts(nProcs, 0);
+        labelListList patchSizes(nProcs, labelList(nPhysical, 0));
+        labelListList patchStarts(nProcs, labelList(nPhysical, 0));
+
+        label nTotalCells = nOldCells_, nTotalIntFaces = nOldInternalFaces_;
+        labelList nTotalPatchFaces(SubList<label>(oldPatchSizes_, nPhysical));
+
+        forAll(procIndices_, pI)
+        {
+            const coupleMap& cMap = recvMeshes_[pI].map();
+
+            // Fetch size from subMesh
+            label nCells = cMap.nEntities(coupleMap::CELL);
+            label nIntFaces = cMap.nEntities(coupleMap::INTERNAL_FACE);
+
+            // Set size / offset for this processor
+            cellSizes[pI] = nCells;
+            cellStarts[pI] = nTotalCells;
+
+            faceSizes[pI] = nIntFaces;
+            faceStarts[pI] = nTotalIntFaces;
+
+            // Update count
+            nTotalCells += nCells;
+            nTotalIntFaces += nIntFaces;
+
+            // Fetch patch sizes from subMesh
+            const labelList& nPatchFaces =
+            (
+                cMap.entityBuffer(coupleMap::FACE_SIZES)
+            );
+
+            // Loop over physical patches
+            forAll(nTotalPatchFaces, patchI)
+            {
+                // Fetch patch size from subMesh
+                label nFaces = nPatchFaces[patchI];
+
+                // Set patch size / offset for this processor
+                patchSizes[pI][patchI] = nFaces;
+                patchStarts[pI][patchI] = nTotalPatchFaces[patchI];
+
+                // Update patch count
+                nTotalPatchFaces[patchI] += nFaces;
+            }
+        }
+
+        // Set sizes / starts in mapper
+        mapper_->setOffsets
+        (
+            cellSizes,
+            cellStarts,
+            faceSizes,
+            faceStarts,
+            patchSizes,
+            patchStarts
+        );
+
+        if (debug > 3)
+        {
+            SubList<label> physicalPatches(oldPatchSizes_, nPhysical);
+
+            Pout<< " procIndices: " << procIndices_ << nl
+                << " nCells: " << nOldCells_ << nl
+                << " proc cellSizes: " << cellSizes << nl
+                << " cellStarts: " << cellStarts << nl
+                << " proc faceSizes: " << faceSizes << nl
+                << " faceStarts: " << faceStarts << nl
+                << " patchSizes: " << physicalPatches << nl
+                << " proc patchSizes: " << patchSizes << nl
+                << " patchStarts: " << patchStarts << endl;
+        }
+    }
+
+    // Optionally switch off topo-changes
+    // on processor patches at run-time
+    bool procTopoChanges = true;
+
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+    if (meshSubDict.found("procTopoChanges") || mandatory_)
+    {
+        procTopoChanges = readBool(meshSubDict.lookup("procTopoChanges"));
+    }
+
+    // Set coupled modifications.
+    setCoupledModification();
+
+    // Loop through the coupled stack and perform changes.
+    if (edgeRefinement_)
+    {
+        // Initialize the coupled stack
+        if (procTopoChanges)
+        {
+            initCoupledStack(entities, false);
+        }
+
+        edgeRefinementEngine(&(handlerPtr_[0]));
+    }
+
+    // Re-Initialize the stack
+    if (procTopoChanges)
+    {
+        initCoupledStack(entities, false);
+    }
+
+    if (twoDMesh_)
+    {
+        swap2DEdges(&(handlerPtr_[0]));
+    }
+    else
+    {
+        swap3DEdges(&(handlerPtr_[0]));
+    }
+
+    // Build a list of entities that need to be avoided
+    // by regular topo-changes.
+    buildEntitiesToAvoid(entities, true);
+
+    // Reset coupled modifications.
+    unsetCoupledModification();
+
+    if (debug)
+    {
+        Info<< "Done." << endl;
+
+        // Check coupled-patch sizes after changes.
+        forAll(patchCoupling_, patchI)
+        {
+            if (patchCoupling_(patchI))
+            {
+                const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                label mSize = patchSizes_[cMap.masterIndex()];
+                label sSize = patchSizes_[cMap.slaveIndex()];
+
+                if (mSize != sSize)
+                {
+                    Pout<< "Coupled patch-count is inconsistent." << nl
+                        << " Master Patch: " << cMap.masterIndex()
+                        << " Count: " << mSize << nl
+                        << " Slave Patch: " << cMap.slaveIndex()
+                        << " Count: " << sSize
+                        << endl;
+
+                    FatalErrorIn("dynamicTopoFvMesh::handleCoupledPatches()")
+                        << " Failures were found in connectivity"
+                        << " after coupled topo-changes."
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // Schedule transfer of topology operations across processors
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        coupledInfo& sPM = sendMeshes_[pI];
+        coupledInfo& rPM = recvMeshes_[pI];
+
+        if (proc < Pstream::myProcNo())
+        {
+            const coupleMap& cMap = sPM.map();
+
+            // How many entities am I receiving..
+            label nEntities = -1, nMovePoints = -1;
+
+            meshOps::pRead(proc, nEntities);
+            meshOps::pRead(proc, nMovePoints);
+
+            if (debug > 3)
+            {
+                Pout<< " Op tranfer:"
+                    << " Receiving from [" << proc << "]::"
+                    << " nEntities: " << nEntities
+                    << " nMovePoints: " << nMovePoints
+                    << endl;
+            }
+
+            if (nEntities)
+            {
+                // Size up the receipt buffers
+                labelList& indices = cMap.entityIndices();
+                List<coupleMap::opType>& operations = cMap.entityOperations();
+
+                indices.setSize(nEntities);
+                operations.setSize(nEntities);
+
+                // Schedule indices and operations for receipt
+                meshOps::pRead(proc, indices);
+                meshOps::pRead(proc, operations);
+            }
+
+            if (nMovePoints)
+            {
+                // Size up the receipt buffers
+                pointField& newPoints = cMap.moveNewPoints();
+                pointField& oldPoints = cMap.moveOldPoints();
+
+                newPoints.setSize(nMovePoints);
+                oldPoints.setSize(nMovePoints);
+
+                // Schedule old / new points for receipt
+                meshOps::pRead(proc, newPoints);
+                meshOps::pRead(proc, oldPoints);
+            }
+        }
+        else
+        {
+            const coupleMap& cMap = rPM.map();
+
+            label nEntities = cMap.entityIndices().size();
+            label nMovePoints = cMap.moveNewPoints().size();
+
+            if (debug > 3)
+            {
+                Pout<< " Op tranfer:"
+                    << " Sending to [" << proc << "]:: "
+                    << " nEntities: " << nEntities << nl
+                    << "  entityIndices: " << cMap.entityIndices() << nl
+                    << "  entityOperations: " << cMap.entityOperations() << nl
+                    << " nMovePoints: " << nMovePoints << nl
+                    << "  moveNewPoints: " << cMap.moveNewPoints() << nl
+                    << "  moveOldPoints: " << cMap.moveOldPoints() << nl
+                    << endl;
+            }
+
+            meshOps::pWrite(proc, nEntities);
+            meshOps::pWrite(proc, nMovePoints);
+
+            if (nEntities)
+            {
+                // Schedule transfer to processor
+                meshOps::pWrite(proc, cMap.entityIndices());
+                meshOps::pWrite(proc, cMap.entityOperations());
+            }
+
+            if (nMovePoints)
+            {
+                // Schedule transfer to processor
+                meshOps::pWrite(proc, cMap.moveNewPoints());
+                meshOps::pWrite(proc, cMap.moveOldPoints());
+            }
+        }
+    }
+
+    // We won't wait for transfers to complete for the moment,
+    // and will deal with operations once the internal mesh
+    // has been dealt with.
+}
+
+
+// Synchronize topology operations across processors
+void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    labelList createPatchOrders(Pstream::nProcs(), 0);
+
+    forAll(procIndices_, pI)
+    {
+        const coupleMap& cMap = sendMeshes_[pI].map();
+
+        if (cMap.patchIndex() >= boundary.size())
+        {
+            // This processor needs a new patch talking to me
+            createPatchOrders[procIndices_[pI]] = 1;
+        }
+    }
+
+    // Send / recv create patch orders, if any
+    for (label proc = 0; proc < Pstream::nProcs(); proc++)
+    {
+        if (proc == Pstream::myProcNo())
+        {
+            continue;
+        }
+
+        if (proc > Pstream::myProcNo())
+        {
+            meshOps::pWrite(proc, createPatchOrders[proc]);
+        }
+        else
+        {
+            meshOps::pRead(proc, createPatchOrders[proc]);
+        }
+    }
+
+    Map<label> addedProcPatches;
+
+    for (label proc = 0; proc < Pstream::myProcNo(); proc++)
+    {
+        if (createPatchOrders[proc])
+        {
+            // Create a new processor patch
+            addedProcPatches.insert
+            (
+                proc,
+                createProcessorPatch(proc)
+            );
+        }
+    }
+
+    // Wait for all transfers to complete.
+    meshOps::waitForBuffers();
+
+    // Buffer for cell-removal
+    DynamicList<label> rCellList(10);
+
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        const coupledInfo& sPM = sendMeshes_[pI];
+
+        if (proc < Pstream::myProcNo())
+        {
+            const coupleMap& cMap = sPM.map();
+            const labelList& indices = cMap.entityIndices();
+            const List<coupleMap::opType>& operations = cMap.entityOperations();
+            const pointField& newPoints = cMap.moveNewPoints();
+            const pointField& oldPoints = cMap.moveOldPoints();
+
+            // Find the appropriate processor patch
+            // for cell-removal operations
+            label procPatch = -1;
+
+            forAll(boundary, pI)
+            {
+                if (!isA<processorPolyPatch>(boundary[pI]))
+                {
+                    continue;
+                }
+
+                const processorPolyPatch& pp =
+                (
+                    refCast<const processorPolyPatch>(boundary[pI])
+                );
+
+                if (pp.neighbProcNo() == proc)
+                {
+                    procPatch = pI;
+                    break;
+                }
+            }
+
+            if (procPatch == -1)
+            {
+                // Check if this was a newly added patch
+                if (addedProcPatches.found(proc))
+                {
+                    procPatch = addedProcPatches[proc];
+                }
+                else
+                if (operations.size())
+                {
+                    // If we actually have operations from
+                    // this processor, this is a problem.
+                    Pout<< " * * * Sync Operations * * * " << nl
+                        << " Could not find patch for proc: " << proc << nl
+                        << abort(FatalError);
+                }
+                else
+                {
+                    // Move on to the next processor
+                    continue;
+                }
+            }
+
+            label pointCounter = 0;
+
+            // Sequentially execute operations
+            forAll(indices, indexI)
+            {
+                const label index = indices[indexI];
+                const coupleMap::opType op = operations[indexI];
+
+                if (debug > 3)
+                {
+                    Pout<< " Recv Op index: " << index << endl;
+                }
+
+                // Determine the appropriate local index
+                label localIndex = -1;
+
+                if (op == coupleMap::MOVE_POINT)
+                {
+                    localIndex = cMap.entityMap(coupleMap::POINT)[index];
+                }
+                else
+                if (op == coupleMap::CONVERT_PATCH)
+                {
+                    localIndex =
+                    (
+                        cMap.entityMap(coupleMap::FACE).found(index) ?
+                        cMap.entityMap(coupleMap::FACE)[index] : -1
+                    );
+
+                    if (debug > 3)
+                    {
+                        const point& newCentre = newPoints[pointCounter];
+                        const point& oldCentre = oldPoints[pointCounter];
+
+                        Pout<< " Convert patch: " << index << nl
+                            << " localIndex: " << localIndex << nl
+                            << " newCentre: " << newCentre << nl
+                            << " oldCentre: " << oldCentre << nl
+                            << endl;
+                    }
+                }
+                else
+                {
+                    // Pick localIndex based on entity type
+                    if (twoDMesh_)
+                    {
+                        const Map<label>& fM = cMap.entityMap(coupleMap::FACE);
+
+                        Map<label>::const_iterator it = fM.find(index);
+
+                        if (it != fM.end())
+                        {
+                            localIndex = it();
+                        }
+                        else
+                        {
+                            Pout<< " * * * Sync Operations * * * " << nl
+                                << " Could not find index: " << index
+                                << " in faceMap for proc: " << proc << nl
+                                << " nSentFaces: "
+                                << cMap.nEntities(coupleMap::FACE)
+                                << " opType: " << coupleMap::asText(op)
+                                << abort(FatalError);
+                        }
+                    }
+                    else
+                    {
+                        const Map<label>& eM = cMap.entityMap(coupleMap::EDGE);
+
+                        Map<label>::const_iterator it = eM.find(index);
+
+                        if (it != eM.end())
+                        {
+                            localIndex = it();
+                        }
+                        else
+                        {
+                            Pout<< " * * * Sync Operations * * * " << nl
+                                << " Could not find index: " << index
+                                << " in edgeMap for proc: " << proc << nl
+                                << " nSentEdges: "
+                                << cMap.nEntities(coupleMap::EDGE)
+                                << " opType: " << coupleMap::asText(op)
+                                << abort(FatalError);
+                        }
+                    }
+                }
+
+                changeMap opMap;
+
+                switch (op)
+                {
+                    case coupleMap::BISECTION:
+                    {
+                        opMap = bisectEdge(localIndex);
+                        break;
+                    }
+
+                    case coupleMap::COLLAPSE_FIRST:
+                    {
+                        opMap = collapseEdge(localIndex, 1);
+                        break;
+                    }
+
+                    case coupleMap::COLLAPSE_SECOND:
+                    {
+                        opMap = collapseEdge(localIndex, 2);
+                        break;
+                    }
+
+                    case coupleMap::COLLAPSE_MIDPOINT:
+                    {
+                        opMap = collapseEdge(localIndex, 3);
+                        break;
+                    }
+
+                    case coupleMap::REMOVE_CELL:
+                    {
+                        // Clear existing list
+                        rCellList.clear();
+
+                        if (twoDMesh_)
+                        {
+                            // Insert the owner cell
+                            rCellList.append(owner_[localIndex]);
+                        }
+                        else
+                        {
+                            // Insert all cells connected to this edge
+                            const labelList& eFaces = edgeFaces_[localIndex];
+
+                            forAll(eFaces, faceI)
+                            {
+                                const label own = owner_[eFaces[faceI]];
+                                const label nei = neighbour_[eFaces[faceI]];
+
+                                if (findIndex(rCellList, own) == -1)
+                                {
+                                    rCellList.append(own);
+                                }
+
+                                if (nei != -1)
+                                {
+                                    if (findIndex(rCellList, nei) == -1)
+                                    {
+                                        rCellList.append(nei);
+                                    }
+                                }
+                            }
+                        }
+
+                        opMap =
+                        (
+                            removeCells
+                            (
+                                rCellList,
+                                procPatch,
+                                "rcs_" + Foam::name(localIndex)
+                            )
+                        );
+
+                        break;
+                    }
+
+                    case coupleMap::MOVE_POINT:
+                    {
+                        const point& newPoint = newPoints[pointCounter];
+                        const point& oldPoint = oldPoints[pointCounter];
+
+                        // Move old / new points
+                        points_[localIndex] = newPoint;
+                        oldPoints_[localIndex] = oldPoint;
+
+                        // Clear the existing map
+                        opMap.clear();
+
+                        // Force a successful operation
+                        opMap.type() = 1;
+
+                        pointCounter++;
+
+                        break;
+                    }
+
+                    case coupleMap::CONVERT_PATCH:
+                    {
+                        const point& newCentre = newPoints[pointCounter];
+                        const point& oldCentre = oldPoints[pointCounter];
+
+                        if (localIndex == -1)
+                        {
+                            // Accumulate stats in case of failure
+                            scalar minDist = GREAT;
+                            vector minPoint = vector::zero;
+                            DynamicList<label> checkedFaces;
+
+                            if (debug > 2)
+                            {
+                                // Reserve for append
+                                checkedFaces.setCapacity(50);
+                            }
+
+                            // New face. Check all boundary faces
+                            // and match up centre
+                            label sTot = faces_.size();
+                            label sInt = nOldInternalFaces_;
+
+                            for (label faceI = sInt; faceI < sTot; faceI++)
+                            {
+                                const face& fCheck = faces_[faceI];
+
+                                if (fCheck.empty())
+                                {
+                                    continue;
+                                }
+
+                                label pIndex = whichPatch(faceI);
+
+                                if (getNeighbourProcessor(pIndex) == -1)
+                                {
+                                    continue;
+                                }
+
+                                // Compute face-centre
+                                vector fC = fCheck.centre(points_);
+
+                                // Compute tolerance
+                                scalar tol = mag(points_[fCheck[0]] - fC);
+                                scalar dist = mag(fC - newCentre);
+
+                                if (dist < (1e-4 * tol))
+                                {
+                                    localIndex = faceI;
+                                    break;
+                                }
+                                else
+                                if (dist < minDist)
+                                {
+                                    minPoint = fC;
+                                    minDist = dist;
+
+                                    if (debug > 2)
+                                    {
+                                        checkedFaces.append(faceI);
+                                    }
+                                }
+                            }
+
+                            // Ensure that the face was found
+                            if (localIndex == -1)
+                            {
+                                writeVTK
+                                (
+                                    "checkedFaces_"
+                                  + Foam::name(index),
+                                    checkedFaces,
+                                    2, false, true
+                                );
+
+                                Pout<< " * * * syncCoupledPatches * * * " << nl
+                                    << " Convert patch Op failed." << nl
+                                    << " Face: " << index << nl
+                                    << " minPoint: " << minPoint << nl
+                                    << " minDistance: " << minDist << nl
+                                    << " newCentre: " << newCentre << nl
+                                    << " oldCentre: " << oldCentre << nl
+                                    << abort(FatalError);
+                            }
+                        }
+
+                        // Fetch reference to face
+                        const face& fCheck = faces_[localIndex];
+
+                        point fC = fCheck.centre(points_);
+
+                        // Specify a tolerance
+                        scalar tol = mag(points_[fCheck[0]] - fC);
+                        scalar dist = mag(fC - newCentre);
+
+                        // Ensure a face-match
+                        if (dist > (1e-4 * tol))
+                        {
+                            Pout<< " * * * Sync Operations * * * " << nl
+                                << " Convert patch Op failed." << nl
+                                << " Index: " << index << nl
+                                << " localIndex: " << localIndex << nl
+                                << " face: " << fCheck << nl
+                                << " faceCentre: " << fC << nl
+                                << " Master processor: " << proc << nl
+                                << " procPatch: " << procPatch << nl
+                                << " tolerance: " << tol << nl
+                                << " distance: " << dist << nl
+                                << " pointCounter: " << pointCounter << nl
+                                << " newCentre: " << newCentre << nl
+                                << " oldCentre: " << oldCentre << nl
+                                << abort(FatalError);
+                        }
+
+                        // Obtain a copy before adding the new face,
+                        // since the reference might become
+                        // invalid during list resizing.
+                        face newFace = faces_[localIndex];
+                        label newOwn = owner_[localIndex];
+                        labelList newFaceEdges = faceEdges_[localIndex];
+
+                        label newFaceIndex =
+                        (
+                            insertFace
+                            (
+                                procPatch,
+                                newFace,
+                                newOwn,
+                                -1
+                            )
+                        );
+
+                        // Add a faceEdges entry as well.
+                        // Edges don't have to change, since they're
+                        // all on the boundary anyway.
+                        faceEdges_.append(newFaceEdges);
+
+                        meshOps::replaceLabel
+                        (
+                            localIndex,
+                            newFaceIndex,
+                            cells_[newOwn]
+                        );
+
+                        // Correct edgeFaces with the new face label.
+                        forAll(newFaceEdges, edgeI)
+                        {
+                            meshOps::replaceLabel
+                            (
+                                localIndex,
+                                newFaceIndex,
+                                edgeFaces_[newFaceEdges[edgeI]]
+                            );
+                        }
+
+                        // Finally remove the face
+                        removeFace(localIndex);
+
+                        // Clear the existing map
+                        opMap.clear();
+
+                        // Update map
+                        opMap.addFace
+                        (
+                            newFaceIndex,
+                            labelList(1, localIndex)
+                        );
+
+                        // Force a successful operation
+                        opMap.type() = 1;
+
+                        pointCounter++;
+
+                        break;
+                    }
+
+                    case coupleMap::INVALID:
+                    {
+                        Pout<< " * * * Sync Operations * * * " << nl
+                            << " Invalid operation." << nl
+                            << " Index: " << index << nl
+                            << " localIndex: " << localIndex << nl
+                            << " operation: " << coupleMap::asText(op) << nl
+                            << abort(FatalError);
+
+                        break;
+                    }
+                }
+
+                if (opMap.type() <= 0)
+                {
+                    Pout<< " * * * Sync Operations * * * " << nl
+                        << " Operation failed." << nl
+                        << " Index: " << index << nl
+                        << " localIndex: " << localIndex << nl
+                        << " operation: " << coupleMap::asText(op) << nl
+                        << " opMap.type: " << opMap.type() << nl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    // Re-Initialize the stack with avoided entities from subMeshes
+    // and leave those on processor patches untouched
+    labelHashSet procEntities;
+
+    buildEntitiesToAvoid(procEntities, false);
+
+    // First remove processor entries
+    forAllConstIter(labelHashSet, procEntities, pIter)
+    {
+        if (entities.found(pIter.key()))
+        {
+            entities.erase(pIter.key());
+        }
+    }
+
+    // Initialize the coupled stack, using supplied entities
+    initCoupledStack(entities, true);
+
+    // Loop through the coupled stack and perform changes.
+    if (edgeRefinement_)
+    {
+        edgeRefinementEngine(&(handlerPtr_[0]));
+    }
+
+    // Re-Initialize the stack, using supplied entities
+    initCoupledStack(entities, true);
+
+    if (twoDMesh_)
+    {
+        swap2DEdges(&(handlerPtr_[0]));
+    }
+    else
+    {
+        swap3DEdges(&(handlerPtr_[0]));
+    }
+}
+
+
+// Check the state of coupled boundaries
+//  - Return true if errors are present
+bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
+{
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    bool sizeError = false, misMatchError = false;
+
+    // Check if a geometric tolerance has been specified.
+    scalar gTol = debug::tolerances("processorMatchTol", 1e-4);
+
+    // Maintain a list of master / neighbour anchors
+    List<vectorField> mAnchors(boundary.size());
+    List<vectorField> nAnchors(boundary.size());
+
+    forAll(boundary, pI)
+    {
+        if (isA<processorPolyPatch>(boundary[pI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[pI])
+            );
+
+            label neiProcNo = pp.neighbProcNo();
+
+            // Send point / face sizes
+            meshOps::pWrite(neiProcNo, boundary[pI].nPoints());
+            meshOps::pWrite(neiProcNo, boundary[pI].size());
+
+            // Send points / centres / areas
+            meshOps::pWrite(neiProcNo, boundary[pI].faceAreas());
+            meshOps::pWrite(neiProcNo, boundary[pI].faceCentres());
+            meshOps::pWrite(neiProcNo, boundary[pI].localPoints());
+
+            // Prepare and send anchor points
+            mAnchors[pI].setSize(boundary[pI].size());
+
+            const faceList& lFaces = boundary[pI].localFaces();
+            const pointField& lPoints = boundary[pI].localPoints();
+
+            forAll(lFaces, faceI)
+            {
+                mAnchors[pI][faceI] = lPoints[lFaces[faceI][0]];
+            }
+
+            meshOps::pWrite(neiProcNo, mAnchors[pI]);
+        }
+
+        if (isA<cyclicPolyPatch>(boundary[pI]))
+        {
+            const cyclicPolyPatch& cp =
+            (
+                refCast<const cyclicPolyPatch>(boundary[pI])
+            );
+
+            if (cp.size() & 1)
+            {
+                sizeError = true;
+
+                Pout<< " Incorrect size for cyclic patch: "
+                    << cp.size() << endl;
+            }
+
+            if (!sizeError)
+            {
+                // Compute halfSize
+                label halfSize = cp.size() / 2;
+
+                vectorField half0Areas
+                (
+                    SubField<vector>
+                    (
+                        cp.faceAreas(),
+                        halfSize
+                    )
+                );
+
+                vectorField half0Centres
+                (
+                    SubField<vector>
+                    (
+                        cp.faceCentres(),
+                        halfSize
+                    )
+                );
+
+                vectorField half1Areas
+                (
+                    SubField<vector>
+                    (
+                        cp.faceAreas(),
+                        halfSize,
+                        halfSize
+                    )
+                );
+
+                vectorField half1Centres
+                (
+                    SubField<vector>
+                    (
+                        cp.faceCentres(),
+                        halfSize,
+                        halfSize
+                    )
+                );
+
+                const faceList& lF = boundary[pI].localFaces();
+                const pointField& lP = boundary[pI].localPoints();
+                const vectorField& lC = boundary[pI].faceCentres();
+
+                // Prepare anchor points
+                mAnchors[pI].setSize(boundary[pI].size());
+
+                forAll(lF, faceI)
+                {
+                    mAnchors[pI][faceI] = lP[lF[faceI][0]];
+                }
+
+                // Transform first-half points and check
+                if (cp.transform() == cyclicPolyPatch::ROTATIONAL)
+                {
+                    forAll(half0Centres, faceI)
+                    {
+                        half0Centres[faceI] =
+                        (
+                            Foam::transform
+                            (
+                                cp.transformT(0),
+                                half0Centres[faceI]
+                            )
+                        );
+
+                        mAnchors[pI][faceI] =
+                        (
+                            Foam::transform
+                            (
+                                cp.transformT(0),
+                                mAnchors[pI][faceI]
+                            )
+                        );
+                    }
+                }
+                else
+                if (cp.transform() == cyclicPolyPatch::TRANSLATIONAL)
+                {
+                    forAll(half0Centres, faceI)
+                    {
+                        half0Centres[faceI] += cp.separationVector();
+                        mAnchors[pI][faceI] += cp.separationVector();
+                    }
+                }
+                else
+                {
+                    Pout<< " Cyclic check: Unknown transform."
+                        << abort(FatalError);
+                }
+
+                // Calculate a point-match tolerance per patch
+                scalar pTol = -GREAT;
+
+                // Check areas / compute tolerance
+                forAll(half0Areas, faceI)
+                {
+                    scalar fMagSf = mag(half0Areas[faceI]);
+                    scalar rMagSf = mag(half1Areas[faceI]);
+                    scalar avSf = 0.5 * (fMagSf + rMagSf);
+
+                    if (mag(fMagSf - rMagSf)/avSf > gTol)
+                    {
+                        misMatchError = true;
+
+                        Pout<< " Face: " << faceI
+                            << " area does not match neighbour by: "
+                            << 100 * mag(fMagSf - rMagSf)/avSf
+                            << "% - possible patch ordering problem. "
+                            << " Front area:" << fMagSf
+                            << " Rear area: " << rMagSf
+                            << endl;
+                    }
+
+                    pTol =
+                    (
+                        Foam::max
+                        (
+                            pTol,
+                            gTol * mag(lP[lF[faceI][0]] - lC[faceI])
+                        )
+                    );
+                }
+
+                // Check centres / anchor points
+                forAll(half0Centres, faceI)
+                {
+                    scalar distA =
+                    (
+                        mag
+                        (
+                            mAnchors[pI][faceI]
+                          - mAnchors[pI][faceI + halfSize]
+                        )
+                    );
+
+                    scalar distC =
+                    (
+                        mag
+                        (
+                            half0Centres[faceI]
+                          - half1Centres[faceI]
+                        )
+                    );
+
+                    if (distA > pTol || distC > pTol)
+                    {
+                        misMatchError = true;
+
+                        UIndirectList<point> f1(lP, lF[faceI]);
+                        UIndirectList<point> f2(lP, lF[faceI + halfSize]);
+
+                        Pout<< " Face: " << faceI << nl
+                            << " Points: " << nl << f1 << nl << f2 << nl
+                            << " Anchors ::" << nl
+                            << mAnchors[pI][faceI] << nl
+                            << mAnchors[pI][faceI + halfSize] << nl
+                            << " Centres ::" << nl
+                            << half0Centres[faceI] << nl
+                            << half1Centres[faceI] << nl
+                            << " Tolerance: " << pTol << nl
+                            << " Measured Anchor distance: " << distA << nl
+                            << " Measured Centre distance: " << distC << nl
+                            << endl;
+                    }
+                }
+
+                if (misMatchError)
+                {
+                    // Write out to disk
+                    meshOps::writeVTK
+                    (
+                        (*this),
+                        cp.name(),
+                        identity(cp.size()),
+                        2,
+                        cp.localPoints(),
+                        List<edge>(0),
+                        cp.localFaces()
+                    );
+                }
+            }
+        }
+    }
+
+    // Maintain a list of points / areas / centres
+    List<vectorField> fAreas(boundary.size());
+    List<vectorField> fCentres(boundary.size());
+    List<vectorField> neiPoints(boundary.size());
+
+    forAll(boundary, pI)
+    {
+        if (isA<processorPolyPatch>(boundary[pI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[pI])
+            );
+
+            label neiProcNo = pp.neighbProcNo();
+
+            // Receive point / face sizes
+            label neiPSize = -1, neiSize = -1;
+
+            meshOps::pRead(neiProcNo, neiPSize);
+            meshOps::pRead(neiProcNo, neiSize);
+
+            // Size up lists
+            fAreas[pI].setSize(neiSize);
+            fCentres[pI].setSize(neiSize);
+            neiPoints[pI].setSize(neiPSize);
+            nAnchors[pI].setSize(neiSize);
+
+            // Receive points / centres / areas / anchors
+            meshOps::pRead(neiProcNo, fAreas[pI]);
+            meshOps::pRead(neiProcNo, fCentres[pI]);
+            meshOps::pRead(neiProcNo, neiPoints[pI]);
+            meshOps::pRead(neiProcNo, nAnchors[pI]);
+
+            if
+            (
+                neiSize != boundary[pI].size() ||
+                neiPSize != boundary[pI].nPoints()
+            )
+            {
+                sizeError = true;
+
+                Pout<< "Incorrect send / recv sizes: " << nl
+                    << " Patch: " << boundary[pI].name() << nl
+                    << " My nPoints: " << boundary[pI].nPoints() << nl
+                    << " Nei nPoints: " << neiPSize << nl
+                    << " My nFaces: " << boundary[pI].size() << nl
+                    << " Nei nFaces: " << neiSize << nl
+                    << endl;
+            }
+        }
+    }
+
+    // Wait for transfers to complete
+    meshOps::waitForBuffers();
+
+    // Check centres / areas
+    forAll(boundary, pI)
+    {
+        if (!isA<processorPolyPatch>(boundary[pI]))
+        {
+            continue;
+        }
+
+        const vectorField& myAreas = boundary[pI].faceAreas();
+        const vectorField& myCentres = boundary[pI].faceCentres();
+
+        // Fetch local connectivity
+        const faceList& myFaces = boundary[pI].localFaces();
+        const vectorField& myPoints = boundary[pI].localPoints();
+
+        // Calculate a point-match tolerance per patch
+        scalar pTol = -GREAT;
+
+        forAll(myAreas, faceI)
+        {
+            scalar magSf = mag(myAreas[faceI]);
+            scalar nbrMagSf = mag(fAreas[pI][faceI]);
+            scalar avSf = 0.5 * (magSf + nbrMagSf);
+
+            if (mag(magSf - nbrMagSf)/avSf > gTol)
+            {
+                misMatchError = true;
+
+                Pout<< " Face: " << faceI
+                    << " area does not match neighbour by: "
+                    << 100 * mag(magSf - nbrMagSf)/avSf
+                    << "% - possible patch ordering problem. "
+                    << " My area:" << magSf
+                    << " Neighbour area: " << nbrMagSf
+                    << " My centre: " << myCentres[faceI]
+                    << endl;
+            }
+
+            pTol =
+            (
+                Foam::max
+                (
+                    pTol,
+                    gTol *
+                    mag
+                    (
+                        myPoints[myFaces[faceI][0]]
+                      - myCentres[faceI]
+                    )
+                )
+            );
+        }
+
+        const processorPolyPatch& pp =
+        (
+            refCast<const processorPolyPatch>(boundary[pI])
+        );
+
+        // Check anchor points
+        forAll(mAnchors[pI], faceI)
+        {
+            scalar dist = mag(mAnchors[pI][faceI] - nAnchors[pI][faceI]);
+
+            if (dist > pTol)
+            {
+                misMatchError = true;
+
+                Pout<< " Face: " << faceI << "::" << mAnchors[pI][faceI] << nl
+                    << " Mismatch for processor: " << pp.neighbProcNo() << nl
+                    << " Neighbour Anchor: " << nAnchors[pI][faceI] << nl
+                    << " Tolerance: " << pTol << nl
+                    << " Measured distance: " << dist << nl
+                    << endl;
+            }
+        }
+
+        // Check neighbPoints addressing
+        const labelList& nPts = pp.neighbPoints();
+
+        forAll(myPoints, pointI)
+        {
+            if (nPts[pointI] < 0)
+            {
+                Pout<< " Point: " <<  pointI << "::" << myPoints[pointI]
+                    << " reported to be multiply connected." << nl
+                    << " neighbPoint: " << nPts[pointI] << nl
+                    << endl;
+
+                misMatchError = true;
+
+                continue;
+            }
+
+            scalar dist = mag(myPoints[pointI] - neiPoints[pI][nPts[pointI]]);
+
+            if (dist > pTol)
+            {
+                misMatchError = true;
+
+                Pout<< " Point: " << pointI << "::" << myPoints[pointI] << nl
+                    << " Mismatch for processor: " << pp.neighbProcNo() << nl
+                    << " Neighbour Pt: " << neiPoints[pI][nPts[pointI]] << nl
+                    << " Tolerance: " << pTol << nl
+                    << " Measured distance: " << dist << nl
+                    << " Neighbour Index:" << nPts[pointI] << nl
+                    << endl;
+            }
+        }
+    }
+
+    if (!sizeError && !misMatchError && report)
+    {
+        Pout<< " Coupled boundary check: No problems." << endl;
+    }
+
+    return (sizeError || misMatchError);
+}
+
+
+// Build patch sub-meshes for processor patches
+void dynamicTopoFvMesh::buildProcessorPatchMeshes()
+{
+    if (procIndices_.empty())
+    {
+        return;
+    }
+
+    // Maintain a list of cells common to multiple processors.
+    Map<labelList> commonCells;
+
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        coupledInfo& sPM = sendMeshes_[pI];
+
+        // Build the subMesh.
+        buildProcessorPatchMesh(sPM, commonCells);
+
+        const coupleMap& scMap = sPM.map();
+
+        // Send my sub-mesh to the neighbour.
+        meshOps::pWrite(proc, scMap.nEntities());
+
+        if (debug > 3)
+        {
+            Pout<< "Sending to [" << proc << "]:: nEntities: "
+                << scMap.nEntities() << endl;
+        }
+
+        // Send the pointBuffers
+        meshOps::pWrite(proc, scMap.pointBuffer());
+        meshOps::pWrite(proc, scMap.oldPointBuffer());
+
+        // Send connectivity (points, edges, faces, cells, etc)
+        forAll(scMap.entityBuffer(), bufferI)
+        {
+            if (scMap.entityBuffer(bufferI).size())
+            {
+                meshOps::pWrite(proc, scMap.entityBuffer(bufferI));
+            }
+        }
+
+        // Obtain references
+        const coupledInfo& rPM = recvMeshes_[pI];
+        const coupleMap& rcMap = rPM.map();
+
+        // First read entity sizes.
+        meshOps::pRead(proc, rcMap.nEntities());
+
+        if (debug > 3)
+        {
+            Pout<< "Receiving from [" << proc << "]:: nEntities: "
+                << rcMap.nEntities() << endl;
+        }
+
+        // Size the buffers.
+        rcMap.allocateBuffers();
+
+        // Receive the pointBuffers
+        meshOps::pRead(proc, rcMap.pointBuffer());
+        meshOps::pRead(proc, rcMap.oldPointBuffer());
+
+        // Receive connectivity (points, edges, faces, cells, etc)
+        forAll(rcMap.entityBuffer(), bufferI)
+        {
+            if (rcMap.entityBuffer(bufferI).size())
+            {
+                meshOps::pRead(proc, rcMap.entityBuffer(bufferI));
+            }
+        }
+    }
+
+    // We won't wait for all transfers to complete for the moment.
+    // Meanwhile, do some other useful work, if possible.
+}
+
+
+// Build patch sub-mesh for a specified processor
+// - At this point, procIndices is available as a sorted list
+//   of neighbouring processors.
+void dynamicTopoFvMesh::buildProcessorPatchMesh
+(
+    coupledInfo& subMesh,
+    Map<labelList>& commonCells
+)
+{
+    label nP = 0, nE = 0, nF = 0, nC = 0;
+
+    // Obtain references
+    const coupleMap& cMap = subMesh.map();
+    const labelList& subMeshPoints = cMap.subMeshPoints();
+    const List<labelPair>& globalProcPoints = cMap.globalProcPoints();
+
+    Map<label>& rPointMap = cMap.reverseEntityMap(coupleMap::POINT);
+    Map<label>& rEdgeMap = cMap.reverseEntityMap(coupleMap::EDGE);
+    Map<label>& rFaceMap = cMap.reverseEntityMap(coupleMap::FACE);
+    Map<label>& rCellMap = cMap.reverseEntityMap(coupleMap::CELL);
+
+    Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+    Map<label>& edgeMap = cMap.entityMap(coupleMap::EDGE);
+    Map<label>& faceMap = cMap.entityMap(coupleMap::FACE);
+    Map<label>& cellMap = cMap.entityMap(coupleMap::CELL);
+
+    // Add all cells connected to points on the subMeshPoints list
+    label proc = -1;
+
+    if (cMap.masterIndex() == Pstream::myProcNo())
+    {
+        proc = cMap.slaveIndex();
+    }
+    else
+    {
+        proc = cMap.masterIndex();
+    }
+
+    // Check if this is a direct neighbour
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    label patchIndex = -1;
+
+    forAll(boundary, patchI)
+    {
+        if (isA<processorPolyPatch>(boundary[patchI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[patchI])
+            );
+
+            if (pp.neighbProcNo() == proc)
+            {
+                patchIndex = patchI;
+
+                break;
+            }
+        }
+    }
+
+    // Add sub-mesh points first.
+    // Additional halo points will be added later.
+    forAll(subMeshPoints, pointI)
+    {
+        pointMap.insert(nP, subMeshPoints[pointI]);
+        rPointMap.insert(subMeshPoints[pointI], nP);
+        nP++;
+    }
+
+    // Set the number of points (shared) at this point.
+    cMap.nEntities(coupleMap::SHARED_POINT) = nP;
+
+    // Size up the point-buffer with global index information.
+    // Direct neighbours do not require any addressing.
+    labelList& gpBuffer = cMap.entityBuffer(coupleMap::POINT);
+    gpBuffer.setSize(globalProcPoints.size(), -1);
+
+    forAll(globalProcPoints, pointI)
+    {
+        pointMap.insert(nP, globalProcPoints[pointI].first());
+        rPointMap.insert(globalProcPoints[pointI].first(), nP);
+        nP++;
+
+        // Fill in buffer with global point index
+        gpBuffer[pointI] = globalProcPoints[pointI].second();
+    }
+
+    // Set the number of points (shared + global) at this point.
+    cMap.nEntities(coupleMap::GLOBAL_POINT) = nP;
+
+    labelHashSet localCommonCells;
+
+    // Detect all cells surrounding shared points.
+    if (twoDMesh_)
+    {
+        // No pointEdges structure, so loop through all cells
+        // to check for those connected to subMeshPoints
+        forAll(cells_, cellI)
+        {
+            const cell& cellToCheck = cells_[cellI];
+            const labelList cellPoints = cellToCheck.labels(faces_);
+
+            forAll(cellPoints, pointI)
+            {
+                if (rPointMap.found(cellPoints[pointI]))
+                {
+                    if (commonCells.found(cellI))
+                    {
+                        // Add locally common cells at the end.
+                        if (!localCommonCells.found(cellI))
+                        {
+                            localCommonCells.insert(cellI);
+                        }
+
+                        // Check if the processor exists on the list
+                        // and if not, add it.
+                        labelList& procList = commonCells[cellI];
+
+                        if (findIndex(procList, proc) == -1)
+                        {
+                            meshOps::sizeUpList(proc, procList);
+                        }
+                    }
+                    else
+                    {
+                        cellMap.insert(nC, cellI);
+                        rCellMap.insert(cellI, nC);
+                        nC++;
+
+                        commonCells.insert(cellI, labelList(1, proc));
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
+    else
+    {
+        forAllConstIter(Map<label>, rPointMap, pIter)
+        {
+            // Loop through pointEdges for this point.
+            const labelList& pEdges = pointEdges_[pIter.key()];
+
+            forAll(pEdges, edgeI)
+            {
+                const labelList& eFaces = edgeFaces_[pEdges[edgeI]];
+
+                forAll(eFaces, faceI)
+                {
+                    label own = owner_[eFaces[faceI]];
+                    label nei = neighbour_[eFaces[faceI]];
+
+                    // Check owner cell
+                    if (!rCellMap.found(own))
+                    {
+                        if (commonCells.found(own))
+                        {
+                            // Add locally common cells at the end.
+                            if (!localCommonCells.found(own))
+                            {
+                                localCommonCells.insert(own);
+                            }
+
+                            // Check if the processor exists on the list
+                            // and if not, add it.
+                            labelList& procList = commonCells[own];
+
+                            if (findIndex(procList, proc) == -1)
+                            {
+                                meshOps::sizeUpList(proc, procList);
+                            }
+                        }
+                        else
+                        {
+                            cellMap.insert(nC, own);
+                            rCellMap.insert(own, nC);
+                            nC++;
+
+                            commonCells.insert(own, labelList(1, proc));
+                        }
+                    }
+
+                    // Check neighbour cell
+                    if (!rCellMap.found(nei) && nei != -1)
+                    {
+                        if (commonCells.found(nei))
+                        {
+                            // Add locally common cells at the end.
+                            if (!localCommonCells.found(nei))
+                            {
+                                localCommonCells.insert(nei);
+                            }
+
+                            // Check if the processor exists on the list
+                            // and if not, add it.
+                            labelList& procList = commonCells[nei];
+
+                            if (findIndex(procList, proc) == -1)
+                            {
+                                meshOps::sizeUpList(proc, procList);
+                            }
+                        }
+                        else
+                        {
+                            cellMap.insert(nC, nei);
+                            rCellMap.insert(nei, nC);
+                            nC++;
+
+                            commonCells.insert(nei, labelList(1, proc));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Now add locally common cells.
+    forAllConstIter(labelHashSet, localCommonCells, cIter)
+    {
+        cellMap.insert(nC, cIter.key());
+        rCellMap.insert(cIter.key(), nC);
+        nC++;
+    }
+
+    // Keep track of inserted boundary face indices
+    // - Add exposed internal faces to a 'default' patch
+    //   at the end of the list.
+    labelList bdyFaceSizes(boundary.size() + 1, 0);
+    labelList bdyFaceStarts(boundary.size() + 1, 0);
+    List<Map<label> > bdyFaceIndices(boundary.size() + 1);
+
+    // Allocate the faceMap. Since the number of internal faces is unknown,
+    // detect internal ones first and update boundaries later.
+    label sumNFE = 0;
+
+    forAllConstIter(Map<label>, rCellMap, cIter)
+    {
+        const cell& thisCell = cells_[cIter.key()];
+
+        forAll(thisCell, faceI)
+        {
+            label fIndex = thisCell[faceI];
+
+            if (!rFaceMap.found(fIndex))
+            {
+                // Determine the patch index
+                label patchID = whichPatch(fIndex);
+
+                if (patchID == -1)
+                {
+                    // Internal face. Check if this needs to
+                    // be added to the 'default' patch.
+                    label own = owner_[fIndex];
+                    label nei = neighbour_[fIndex];
+
+                    if (rCellMap.found(own) && rCellMap.found(nei))
+                    {
+                        faceMap.insert(nF, fIndex);
+                        rFaceMap.insert(fIndex, nF);
+                        nF++;
+                    }
+                    else
+                    {
+                        // Update boundary maps.
+                        label bfI = bdyFaceSizes[boundary.size()]++;
+
+                        // Skip faceMap and update the reverseMap for now.
+                        // faceMap will be updated once all
+                        // internal faces have been detected.
+                        rFaceMap.insert(fIndex, bfI);
+                        bdyFaceIndices[boundary.size()].insert(bfI, fIndex);
+                    }
+                }
+                else
+                {
+                    // Update boundary maps.
+                    label bfI = bdyFaceSizes[patchID]++;
+
+                    // Skip faceMap and update the reverseMap for now.
+                    // faceMap will be updated once all
+                    // internal faces have been detected.
+                    rFaceMap.insert(fIndex, bfI);
+                    bdyFaceIndices[patchID].insert(bfI, fIndex);
+                }
+
+                // Accumulate face sizes
+                sumNFE += faces_[fIndex].size();
+            }
+        }
+    }
+
+    // Set the number of internal faces at this point
+    cMap.nEntities(coupleMap::INTERNAL_FACE) = nF;
+
+    // Set patch starts
+    bdyFaceStarts[0] = nF;
+
+    for (label i = 1; i < bdyFaceStarts.size(); i++)
+    {
+        bdyFaceStarts[i] = bdyFaceStarts[i-1] + bdyFaceSizes[i-1];
+    }
+
+    // Update faceMap and reverseFaceMap for boundaries
+    forAll(bdyFaceIndices, patchI)
+    {
+        label pStart = bdyFaceStarts[patchI];
+
+        forAllConstIter(Map<label>, bdyFaceIndices[patchI], fIter)
+        {
+            faceMap.insert(fIter.key() + pStart, fIter());
+            rFaceMap[fIter()] = fIter.key() + pStart;
+        }
+
+        // Update face-count
+        nF += bdyFaceSizes[patchI];
+    }
+
+    // Keep track of inserted boundary edge indices
+    // - Add exposed internal edges to a 'default' patch
+    //   at the end of the list.
+    labelList bdyEdgeSizes(boundary.size() + 1, 0);
+    labelList bdyEdgeStarts(boundary.size() + 1, 0);
+    List<Map<label> > bdyEdgeIndices(boundary.size() + 1);
+
+    // Allocate the edgeMap. Since the number of internal edges is unknown,
+    // detect internal ones first and update boundaries later.
+    forAllConstIter(Map<label>, rFaceMap, fIter)
+    {
+        const labelList& fEdges = faceEdges_[fIter.key()];
+
+        forAll(fEdges, edgeI)
+        {
+            label eIndex = fEdges[edgeI];
+
+            if (!rEdgeMap.found(eIndex))
+            {
+                // Determine the patch index
+                label patchID = whichEdgePatch(eIndex);
+
+                if (patchID == -1)
+                {
+                    bool boundaryEdge = false;
+
+                    // Check if any cells touching edgeFaces
+                    // do not belong to the cellMap.
+                    const labelList& eFaces = edgeFaces_[eIndex];
+
+                    forAll(eFaces, faceI)
+                    {
+                        label fIndex = eFaces[faceI];
+
+                        label own = owner_[fIndex];
+                        label nei = neighbour_[fIndex];
+
+                        if (!rCellMap.found(own) || !rCellMap.found(nei))
+                        {
+                            boundaryEdge = true;
+                            break;
+                        }
+                    }
+
+                    if (boundaryEdge)
+                    {
+                        // Update boundary maps.
+                        label beI = bdyEdgeSizes[boundary.size()]++;
+
+                        // Skip edgeMap and update the reverseMap for now.
+                        // edgeMap will be updated once all
+                        // internal edges have been detected.
+                        rEdgeMap.insert(eIndex, beI);
+                        bdyEdgeIndices[boundary.size()].insert(beI, eIndex);
+                    }
+                    else
+                    {
+                        // Internal edge
+                        edgeMap.insert(nE, eIndex);
+                        rEdgeMap.insert(eIndex, nE);
+                        nE++;
+                    }
+                }
+                else
+                {
+                    // Update boundary maps.
+                    label beI = bdyEdgeSizes[patchID]++;
+
+                    // Skip edgeMap and update the reverseMap for now.
+                    // edgeMap will be updated once all
+                    // internal edges have been detected.
+                    rEdgeMap.insert(eIndex, beI);
+                    bdyEdgeIndices[patchID].insert(beI, eIndex);
+                }
+            }
+        }
+    }
+
+    // Set the number of internal edges at this point
+    cMap.nEntities(coupleMap::INTERNAL_EDGE) = nE;
+
+    // Set patch starts
+    bdyEdgeStarts[0] = nE;
+
+    for (label i = 1; i < bdyEdgeStarts.size(); i++)
+    {
+        bdyEdgeStarts[i] = bdyEdgeStarts[i-1] + bdyEdgeSizes[i-1];
+    }
+
+    // Update edgeMap and reverseEdgeMap for boundaries
+    forAll(bdyEdgeIndices, patchI)
+    {
+        label pStart = bdyEdgeStarts[patchI];
+
+        forAllConstIter(Map<label>, bdyEdgeIndices[patchI], eIter)
+        {
+            edgeMap.insert(eIter.key() + pStart, eIter());
+            rEdgeMap[eIter()] = eIter.key() + pStart;
+        }
+
+        // Update edge-count
+        nE += bdyEdgeSizes[patchI];
+    }
+
+    // Set additional points in the pointMap
+    forAllConstIter(Map<label>, rEdgeMap, eIter)
+    {
+        const edge& thisEdge = edges_[eIter.key()];
+
+        if (!rPointMap.found(thisEdge[0]))
+        {
+            pointMap.insert(nP, thisEdge[0]);
+            rPointMap.insert(thisEdge[0], nP);
+            nP++;
+        }
+
+        if (!rPointMap.found(thisEdge[1]))
+        {
+            pointMap.insert(nP, thisEdge[1]);
+            rPointMap.insert(thisEdge[1], nP);
+            nP++;
+        }
+    }
+
+    // Assign sizes to the mesh
+    cMap.nEntities(coupleMap::POINT) = nP;
+    cMap.nEntities(coupleMap::EDGE) = nE;
+    cMap.nEntities(coupleMap::FACE) = nF;
+    cMap.nEntities(coupleMap::CELL) = nC;
+    cMap.nEntities(coupleMap::NFE_SIZE) = sumNFE;
+    cMap.nEntities(coupleMap::NBDY) = boundary.size() + 1;
+
+    // Size up buffers and fill them
+    cMap.allocateBuffers();
+
+    pointField& pBuffer = cMap.pointBuffer();
+    pointField& opBuffer = cMap.oldPointBuffer();
+
+    forAllConstIter(Map<label>, pointMap, pIter)
+    {
+        pBuffer[pIter.key()] = points_[pIter()];
+        opBuffer[pIter.key()] = oldPoints_[pIter()];
+    }
+
+    label index = 0;
+
+    // Edge buffer size: 2 points for every edge
+    labelList& eBuffer = cMap.entityBuffer(coupleMap::EDGE);
+
+    for (label i = 0; i < nE; i++)
+    {
+        label eIndex = edgeMap[i];
+        const edge& edgeToCheck = edges_[eIndex];
+
+        eBuffer[index++] = rPointMap[edgeToCheck[0]];
+        eBuffer[index++] = rPointMap[edgeToCheck[1]];
+    }
+
+    index = 0;
+    face thisFace;
+    labelList& fBuffer = cMap.entityBuffer(coupleMap::FACE);
+    labelList& fOwner = cMap.entityBuffer(coupleMap::OWNER);
+    labelList& fNeighbour = cMap.entityBuffer(coupleMap::NEIGHBOUR);
+    labelList& feBuffer = cMap.entityBuffer(coupleMap::FACE_EDGE);
+
+    for (label i = 0; i < nF; i++)
+    {
+        label fIndex = faceMap[i];
+        label own = owner_[fIndex];
+        label nei = neighbour_[fIndex];
+
+        // Fetch mapped addressing
+        label fOwn = rCellMap.found(own) ? rCellMap[own] : -1;
+        label fNei = rCellMap.found(nei) ? rCellMap[nei] : -1;
+
+        if (fOwn > -1)
+        {
+            // Check if this face is pointed the right way
+            if ((fNei > -1) && (fNei < fOwn))
+            {
+                thisFace = faces_[fIndex].reverseFace();
+                fOwner[i] = fNei;
+                fNeighbour[i] = fOwn;
+            }
+            else
+            {
+                thisFace = faces_[fIndex];
+                fOwner[i] = fOwn;
+
+                if (fNei > -1)
+                {
+                    fNeighbour[i] = fNei;
+                }
+            }
+        }
+        else
+        {
+            // This face is pointed the wrong way.
+            thisFace = faces_[fIndex].reverseFace();
+            fOwner[i] = fNei;
+        }
+
+        const labelList& fEdges = faceEdges_[fIndex];
+
+        forAll(fEdges, indexI)
+        {
+            fBuffer[index] = rPointMap[thisFace[indexI]];
+            feBuffer[index] = rEdgeMap[fEdges[indexI]];
+
+            index++;
+        }
+    }
+
+    // Fill variable size face-list sizes for 2D
+    if (twoDMesh_)
+    {
+        labelList& nfeBuffer = cMap.entityBuffer(coupleMap::NFE_BUFFER);
+
+        forAllConstIter(Map<label>, faceMap, fIter)
+        {
+            nfeBuffer[fIter.key()] = faces_[fIter()].size();
+        }
+    }
+
+    // Fill in boundary information
+    cMap.entityBuffer(coupleMap::FACE_STARTS) = bdyFaceStarts;
+    cMap.entityBuffer(coupleMap::FACE_SIZES) = bdyFaceSizes;
+    cMap.entityBuffer(coupleMap::EDGE_STARTS) = bdyEdgeStarts;
+    cMap.entityBuffer(coupleMap::EDGE_SIZES) = bdyEdgeSizes;
+
+    labelList& ptBuffer = cMap.entityBuffer(coupleMap::PATCH_ID);
+
+    // Fill types for all but the last one (which is default).
+    forAll(boundary, patchI)
+    {
+        if (isA<processorPolyPatch>(boundary[patchI]))
+        {
+            // Fetch the neighbouring processor ID
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[patchI])
+            );
+
+            // Set processor patches to a special type
+            ptBuffer[patchI] = -2 - pp.neighbProcNo();
+        }
+        else
+        {
+            // Conventional physical patch. Make an identical
+            // map, since physical boundaries are present on
+            // all processors.
+            ptBuffer[patchI] = patchI;
+        }
+    }
+
+    // Fill the default patch as 'internal'
+    ptBuffer[boundary.size()] = -1;
+
+    // Make a temporary dictionary for patch construction
+    dictionary patchDict;
+
+    // Specify the list of patch names and types
+    wordList patchNames(ptBuffer.size());
+
+    forAll(patchNames, patchI)
+    {
+        // Add a new subDictionary
+        dictionary patchSubDict;
+
+        if (patchI == patchNames.size() - 1)
+        {
+            // Artificially set the last patch
+
+            // Set name
+            patchNames[patchI] = "defaultPatch";
+
+            // Add type
+            patchSubDict.add("type", "empty");
+
+            // Add start / size
+            patchSubDict.add("startFace", bdyFaceStarts[patchI]);
+            patchSubDict.add("nFaces", bdyFaceSizes[patchI]);
+        }
+        else
+        if (ptBuffer[patchI] <= -2)
+        {
+            // Back out the neighbouring processor ID
+            label neiProcNo = Foam::mag(ptBuffer[patchI] + 2);
+
+            // Set name
+            patchNames[patchI] =
+            (
+                "procBoundary"
+              + Foam::name(Pstream::myProcNo())
+              + "to"
+              + Foam::name(neiProcNo)
+            );
+
+            // Add type
+            patchSubDict.add("type", "processor");
+
+            // Add start / size
+            patchSubDict.add("startFace", bdyFaceStarts[patchI]);
+            patchSubDict.add("nFaces", bdyFaceSizes[patchI]);
+
+            // Add processor-specific info
+            patchSubDict.add("myProcNo", Pstream::myProcNo());
+            patchSubDict.add("neighbProcNo", neiProcNo);
+        }
+        else
+        {
+            // Set name
+            patchNames[patchI] = boundary[ptBuffer[patchI]].name();
+
+            // Add type
+            patchSubDict.add("type", boundary[ptBuffer[patchI]].type());
+
+            // Add start / size
+            patchSubDict.add("startFace", bdyFaceStarts[patchI]);
+            patchSubDict.add("nFaces", bdyFaceSizes[patchI]);
+        }
+
+        // Add subdictionary
+        patchDict.add(patchNames[patchI], patchSubDict);
+    }
+
+    // Set the autoPtr.
+    subMesh.setMesh
+    (
+        proc,
+        new dynamicTopoFvMesh
+        (
+            (*this),
+            IOobject
+            (
+                fvMesh::defaultRegion,
+                time().timeName(),
+                time()
+            ),
+            xferCopy(cMap.pointBuffer()),
+            xferCopy(cMap.oldPointBuffer()),
+            xferCopy(cMap.edges()),
+            xferCopy(cMap.faces()),
+            xferCopy(cMap.faceEdges()),
+            xferCopy(cMap.owner()),
+            xferCopy(cMap.neighbour()),
+            bdyFaceStarts,
+            bdyFaceSizes,
+            bdyEdgeStarts,
+            bdyEdgeSizes,
+            patchNames,
+            patchDict
+        )
+    );
+
+    // Set maps as built.
+    subMesh.setBuiltMaps();
+
+    // For debugging purposes...
+    if (debug > 3)
+    {
+        Pout<< "Writing out sent subMesh for processor: "
+            << proc << endl;
+
+        writeVTK
+        (
+            "psMesh_"
+          + Foam::name(Pstream::myProcNo())
+          + "to"
+          + Foam::name(proc),
+            rCellMap.toc()
+        );
+
+        // Write out patch information
+        Pout<< " faceStarts: " << bdyFaceStarts << nl
+            << " faceSizes: " << bdyFaceSizes << nl
+            << " edgeStarts: " << bdyEdgeStarts << nl
+            << " edgeSizes: " << bdyEdgeSizes << nl
+            << " patchTypes: " << ptBuffer << endl;
+    }
+}
+
+
+// Build coupled maps for locally coupled patches.
+//   - Performs a geometric match initially, since the mesh provides
+//     no explicit information for topological coupling.
+//   - For each subsequent topology change, maps are updated during
+//     the re-ordering stage.
+void dynamicTopoFvMesh::buildLocalCoupledMaps()
+{
+    if (patchCoupling_.empty())
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< "Building local coupled maps...";
+    }
+
+    // Check if a geometric tolerance has been specified.
+    const boundBox& box = polyMesh::bounds();
+    scalar relTol = debug::tolerances("patchFaceMatchTol", 1e-4);
+
+    // Compute tolerance
+    scalar tol = relTol * box.mag();
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    forAll(patchCoupling_, patchI)
+    {
+        if (!patchCoupling_(patchI))
+        {
+            continue;
+        }
+
+        // Build maps only for the first time.
+        // Information is subsequently mapped for each topo-change.
+        if (patchCoupling_[patchI].builtMaps())
+        {
+            continue;
+        }
+
+        // Deal with cyclics later
+        if (isA<cyclicPolyPatch>(boundary[patchI]))
+        {
+            continue;
+        }
+
+        const coupleMap& cMap = patchCoupling_[patchI].map();
+
+        // Map points on each patch.
+        const labelList& mP = boundary[cMap.masterIndex()].meshPoints();
+        const labelList& sP = boundary[cMap.slaveIndex()].meshPoints();
+
+        // Sanity check: Do patches have equal number of entities?
+        if (mP.size() != sP.size())
+        {
+            FatalErrorIn("void dynamicTopoFvMesh::buildLocalCoupledMaps()")
+                << "Patch point sizes are not consistent."
+                << abort(FatalError);
+        }
+
+        // Check if maps were read from disk.
+        // If so, geometric checking is unnecessary.
+        if (cMap.entityMap(coupleMap::POINT).size() == 0)
+        {
+            // Match points geometrically
+            labelList pointMap(mP.size(), -1);
+
+            bool matchedAll =
+            (
+                matchPoints
+                (
+                    boundary[cMap.masterIndex()].localPoints(),
+                    boundary[cMap.slaveIndex()].localPoints(),
+                    scalarField(mP.size(), tol),
+                    false,
+                    pointMap
+                )
+            );
+
+            if (!matchedAll)
+            {
+                FatalErrorIn("void dynamicTopoFvMesh::buildLocalCoupledMaps()")
+                    << " Failed to match all points"
+                    << " within a tolerance of: " << tol << nl
+                    << " relTol: " << relTol << nl
+                    << abort(FatalError);
+            }
+
+            // Now build maps
+            forAll(mP, indexI)
+            {
+                label masterIndex = mP[indexI];
+                label slaveIndex = sP[pointMap[indexI]];
+
+                cMap.mapSlave
+                (
+                    coupleMap::POINT,
+                    masterIndex,
+                    slaveIndex
+                );
+
+                cMap.mapMaster
+                (
+                    coupleMap::POINT,
+                    slaveIndex,
+                    masterIndex
+                );
+            }
+        }
+
+        const labelListList& mpF = boundary[cMap.masterIndex()].pointFaces();
+        const labelListList& spF = boundary[cMap.slaveIndex()].pointFaces();
+
+        // Fetch reference to maps
+        const Map<label>& pMap = cMap.entityMap(coupleMap::POINT);
+        const Map<label>& eMap = cMap.entityMap(coupleMap::EDGE);
+        const Map<label>& fMap = cMap.entityMap(coupleMap::FACE);
+
+        // Now that all points are matched,
+        // perform topological matching for higher entities.
+        forAll(mP, indexI)
+        {
+            // Fetch global point indices
+            label mp = mP[indexI];
+            label sp = pMap[mp];
+
+            // Fetch local point indices
+            label lmp = boundary[cMap.masterIndex()].whichPoint(mp);
+            label lsp = boundary[cMap.slaveIndex()].whichPoint(sp);
+
+            // Fetch patch starts
+            label mStart = boundary[cMap.masterIndex()].start();
+            label sStart = boundary[cMap.slaveIndex()].start();
+
+            // Match faces for both 2D and 3D.
+            const labelList& mpFaces = mpF[lmp];
+            const labelList& spFaces = spF[lsp];
+
+            forAll(mpFaces, faceI)
+            {
+                // Fetch the global face index
+                label mfIndex = (mStart + mpFaces[faceI]);
+
+                if (fMap.found(mfIndex))
+                {
+                    continue;
+                }
+
+                const face& mFace = faces_[mfIndex];
+
+                if (twoDMesh_)
+                {
+                    // Set up a comparison face.
+                    face cFace(4);
+
+                    // Configure the face for comparison.
+                    forAll(mFace, pointI)
+                    {
+                        cFace[pointI] = pMap[mFace[pointI]];
+                    }
+
+                    bool matched = false;
+
+                    forAll(spFaces, faceJ)
+                    {
+                        // Fetch the global face index
+                        label sfIndex = (sStart + spFaces[faceJ]);
+
+                        const face& sFace = faces_[sfIndex];
+
+                        if (face::compare(cFace, sFace))
+                        {
+                            // Found the slave. Add a map entry
+                            cMap.mapSlave
+                            (
+                                coupleMap::FACE,
+                                mfIndex,
+                                sfIndex
+                            );
+
+                            cMap.mapMaster
+                            (
+                                coupleMap::FACE,
+                                sfIndex,
+                                mfIndex
+                            );
+
+                            matched = true;
+
+                            break;
+                        }
+                    }
+
+                    if (!matched)
+                    {
+                        FatalErrorIn
+                        (
+                            "void dynamicTopoFvMesh::buildLocalCoupledMaps()"
+                        )
+                            << " Failed to match face: "
+                            << mfIndex << ": " << mFace << nl
+                            << " Comparison face: " << cFace
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    label slaveFaceIndex = -1;
+
+                    // Set up a comparison face.
+                    triFace cFace
+                    (
+                        pMap[mFace[0]],
+                        pMap[mFace[1]],
+                        pMap[mFace[2]]
+                    );
+
+                    forAll(spFaces, faceJ)
+                    {
+                        // Fetch the global face index
+                        label sfIndex = (sStart + spFaces[faceJ]);
+
+                        const face& sFace = faces_[sfIndex];
+
+                        if (triFace::compare(cFace, triFace(sFace)))
+                        {
+                            // Found the slave. Add a map entry
+                            cMap.mapSlave
+                            (
+                                coupleMap::FACE,
+                                mfIndex,
+                                sfIndex
+                            );
+
+                            cMap.mapMaster
+                            (
+                                coupleMap::FACE,
+                                sfIndex,
+                                mfIndex
+                            );
+
+                            slaveFaceIndex = sfIndex;
+
+                            break;
+                        }
+                    }
+
+                    if (slaveFaceIndex == -1)
+                    {
+                        FatalErrorIn
+                        (
+                            "void dynamicTopoFvMesh::buildLocalCoupledMaps()"
+                        )
+                            << " Failed to match face: "
+                            << mfIndex << ": " << mFace << nl
+                            << " Comparison face: " << cFace
+                            << abort(FatalError);
+                    }
+
+                    // Match all edges on this face as well.
+                    const labelList& mfEdges = faceEdges_[mfIndex];
+                    const labelList& sfEdges = faceEdges_[slaveFaceIndex];
+
+                    forAll(mfEdges, edgeI)
+                    {
+                        if (eMap.found(mfEdges[edgeI]))
+                        {
+                            continue;
+                        }
+
+                        const edge& mEdge = edges_[mfEdges[edgeI]];
+
+                        // Configure a comparison edge.
+                        edge cEdge(pMap[mEdge[0]], pMap[mEdge[1]]);
+
+                        bool matchedEdge = false;
+
+                        forAll(sfEdges, edgeJ)
+                        {
+                            const edge& sEdge = edges_[sfEdges[edgeJ]];
+
+                            if (cEdge == sEdge)
+                            {
+                                // Found the slave. Add a map entry
+                                cMap.mapSlave
+                                (
+                                    coupleMap::EDGE,
+                                    mfEdges[edgeI],
+                                    sfEdges[edgeJ]
+                                );
+
+                                cMap.mapMaster
+                                (
+                                    coupleMap::EDGE,
+                                    sfEdges[edgeJ],
+                                    mfEdges[edgeI]
+                                );
+
+                                matchedEdge = true;
+
+                                break;
+                            }
+                        }
+
+                        if (!matchedEdge)
+                        {
+                            FatalErrorIn
+                            (
+                                "void dynamicTopoFvMesh::"
+                                "buildLocalCoupledMaps()"
+                            )
+                                << " Failed to match edge: "
+                                << mfEdges[edgeI] << ": "
+                                << mEdge << nl
+                                << " cEdge: " << cEdge
+                                << abort(FatalError);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Set maps as built
+        patchCoupling_[patchI].setBuiltMaps();
+    }
+
+    // Build maps for cyclics
+    forAll(patchCoupling_, patchI)
+    {
+        if (!patchCoupling_(patchI))
+        {
+            continue;
+        }
+
+        // Build maps only for the first time.
+        // Information is subsequently mapped for each topo-change.
+        if (patchCoupling_[patchI].builtMaps())
+        {
+            continue;
+        }
+
+        // Skip if not cyclic
+        if (!isA<cyclicPolyPatch>(boundary[patchI]))
+        {
+            continue;
+        }
+
+        const coupleMap& cMap = patchCoupling_[patchI].map();
+
+        // Match faces and points in one go
+        label halfSize = boundary[patchI].size() / 2;
+        label patchStart = boundary[patchI].start();
+
+        // Fetch reference to map
+        const Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+
+        for (label i = 0; i < halfSize; i++)
+        {
+            label half0Index = (i + patchStart);
+            label half1Index = (i + halfSize + patchStart);
+
+            // Map the face
+            cMap.mapSlave
+            (
+                coupleMap::FACE,
+                half0Index,
+                half1Index
+            );
+
+            cMap.mapMaster
+            (
+                coupleMap::FACE,
+                half1Index,
+                half0Index
+            );
+
+            const face& half0Face = faces_[half0Index];
+            const face& half1Face = faces_[half1Index];
+
+            label fS = half0Face.size();
+
+            forAll(half0Face, pointI)
+            {
+                if (pointMap.found(half0Face[pointI]))
+                {
+                    continue;
+                }
+
+                label masterIndex = half0Face[pointI];
+                label slaveIndex = half1Face[(fS - pointI) % fS];
+
+                // Map the point
+                cMap.mapSlave
+                (
+                    coupleMap::POINT,
+                    masterIndex,
+                    slaveIndex
+                );
+
+                cMap.mapMaster
+                (
+                    coupleMap::POINT,
+                    slaveIndex,
+                    masterIndex
+                );
+            }
+
+            if (twoDMesh_)
+            {
+                continue;
+            }
+
+            // Fetch reference to map
+            const Map<label>& edgeMap = cMap.entityMap(coupleMap::EDGE);
+
+            const labelList& f0Edges = faceEdges_[half0Index];
+            const labelList& f1Edges = faceEdges_[half1Index];
+
+            forAll(f0Edges, edgeI)
+            {
+                if (edgeMap.found(f0Edges[edgeI]))
+                {
+                    continue;
+                }
+
+                const edge& mEdge = edges_[f0Edges[edgeI]];
+
+                // Build a comparison edge
+                edge cEdge(pointMap[mEdge[0]], pointMap[mEdge[1]]);
+
+                forAll(f1Edges, edgeJ)
+                {
+                    const edge& sEdge = edges_[f1Edges[edgeJ]];
+
+                    if (sEdge == cEdge)
+                    {
+                        // Map the edge
+                        cMap.mapSlave
+                        (
+                            coupleMap::EDGE,
+                            f0Edges[edgeI],
+                            f1Edges[edgeJ]
+                        );
+
+                        cMap.mapMaster
+                        (
+                            coupleMap::EDGE,
+                            f1Edges[edgeJ],
+                            f0Edges[edgeI]
+                        );
+
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    if (debug)
+    {
+        Info<< "Done." << endl;
+    }
+}
+
+
+// Build coupled maps for coupled processor patches
+void dynamicTopoFvMesh::buildProcessorCoupledMaps()
+{
+    if (procIndices_.empty())
+    {
+        return;
+    }
+
+    Map<label> nPrc;
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Build a list of nearest neighbours.
+    forAll(boundary, patchI)
+    {
+        if (isA<processorPolyPatch>(boundary[patchI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[patchI])
+            );
+
+            nPrc.insert(pp.neighbProcNo(), patchI);
+        }
+    }
+
+    // Wait for all transfers to complete.
+    meshOps::waitForBuffers();
+
+    // Put un-matched faces in a list.
+    labelHashSet unMatchedFaces;
+
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        coupledInfo& rPM = recvMeshes_[pI];
+        const coupleMap& cMap = rPM.map();
+        const labelList& ptBuffer = cMap.entityBuffer(coupleMap::PATCH_ID);
+
+        // Fetch reference to patch starts / sizes
+        const labelList& faceStarts = cMap.entityBuffer(coupleMap::FACE_STARTS);
+        const labelList& faceSizes = cMap.entityBuffer(coupleMap::FACE_SIZES);
+        const labelList& edgeStarts = cMap.entityBuffer(coupleMap::EDGE_STARTS);
+        const labelList& edgeSizes = cMap.entityBuffer(coupleMap::EDGE_SIZES);
+
+        // Make a temporary dictionary for patch construction
+        dictionary patchDict;
+
+        // Specify the list of patch names and types
+        wordList patchNames(ptBuffer.size());
+
+        forAll(patchNames, patchI)
+        {
+            // Add a new subDictionary
+            dictionary patchSubDict;
+
+            if (patchI == patchNames.size() - 1)
+            {
+                // Artificially set the last patch
+
+                // Set name
+                patchNames[patchI] = "defaultPatch";
+
+                // Add type
+                patchSubDict.add("type", "empty");
+
+                // Add start / size
+                patchSubDict.add("startFace", faceStarts[patchI]);
+                patchSubDict.add("nFaces", faceSizes[patchI]);
+            }
+            else
+            if (ptBuffer[patchI] <= -2)
+            {
+                // Back out the neighbouring processor ID
+                label neiProcNo = Foam::mag(ptBuffer[patchI] + 2);
+
+                // Set name
+                patchNames[patchI] =
+                (
+                    "procBoundary"
+                  + Foam::name(proc)
+                  + "to"
+                  + Foam::name(neiProcNo)
+                );
+
+                // Add type
+                patchSubDict.add("type", "processor");
+
+                // Add start / size
+                patchSubDict.add("startFace", faceStarts[patchI]);
+                patchSubDict.add("nFaces", faceSizes[patchI]);
+
+                // Add processor-specific info
+                patchSubDict.add("myProcNo", proc);
+                patchSubDict.add("neighbProcNo", neiProcNo);
+            }
+            else
+            {
+                // Set name
+                patchNames[patchI] = boundary[ptBuffer[patchI]].name();
+
+                // Add type
+                patchSubDict.add("type", boundary[ptBuffer[patchI]].type());
+
+                // Add start / size
+                patchSubDict.add("startFace", faceStarts[patchI]);
+                patchSubDict.add("nFaces", faceSizes[patchI]);
+            }
+
+            // Add subdictionary
+            patchDict.add(patchNames[patchI], patchSubDict);
+        }
+
+        // Set the autoPtr.
+        rPM.setMesh
+        (
+            proc,
+            new dynamicTopoFvMesh
+            (
+                (*this),
+                IOobject
+                (
+                    fvMesh::defaultRegion,
+                    time().timeName(),
+                    time()
+                ),
+                xferCopy(cMap.pointBuffer()),
+                xferCopy(cMap.oldPointBuffer()),
+                xferCopy(cMap.edges()),
+                xferCopy(cMap.faces()),
+                xferCopy(cMap.faceEdges()),
+                xferCopy(cMap.owner()),
+                xferCopy(cMap.neighbour()),
+                faceStarts,
+                faceSizes,
+                edgeStarts,
+                edgeSizes,
+                patchNames,
+                patchDict
+            )
+        );
+
+        if (debug > 3)
+        {
+            Pout<< "Writing out received subMesh for processor: "
+                << proc << endl;
+
+            rPM.subMesh().writeVTK
+            (
+                "rPatchMesh_"
+              + Foam::name(Pstream::myProcNo())
+              + "to"
+              + Foam::name(proc),
+                identity(cMap.nEntities(coupleMap::CELL))
+            );
+        }
+
+        // First, topologically map points based on subMeshPoints.
+        const labelList& mP = cMap.subMeshPoints();
+
+        label nShared = cMap.nEntities(coupleMap::SHARED_POINT);
+        label nGlobal = cMap.nEntities(coupleMap::GLOBAL_POINT);
+
+        // Sanity check: Do sub-mesh point sizes match?
+        if (mP.size() != nShared)
+        {
+            FatalErrorIn("void dynamicTopoFvMesh::buildProcessorCoupledMaps()")
+                << " Sub-mesh point sizes don't match." << nl
+                << " My procID: " << Pstream::myProcNo() << nl
+                << " Neighbour processor: " << proc << nl
+                << " mP size: " << mP.size() << nl
+                << " nShared: " << nShared << nl
+                << abort(FatalError);
+        }
+
+        if (nPrc.found(proc))
+        {
+            // This is an immediate neighbour.
+            // All patch points must be matched.
+
+            // Fetch addressing for this patch.
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[nPrc[proc]])
+            );
+
+            const labelList& neiPoints = pp.neighbPoints();
+
+            if (debug)
+            {
+                // Find all occurrences of multiply connected points
+                labelList mIdx = findIndices(neiPoints, -1);
+
+                if (mIdx.size())
+                {
+                    // Write out for post-processing
+                    UIndirectList<label> myIdx(mP, mIdx);
+                    writeVTK("mcPoints", labelList(myIdx), 0);
+
+                    FatalErrorIn
+                    (
+                        "void dynamicTopoFvMesh::buildProcessorCoupledMaps()"
+                    )
+                        << " Multiply connected point." << nl
+                        << " My procID: " << Pstream::myProcNo() << nl
+                        << " Neighbour processor: " << proc << nl
+                        << " Neighbour Indices: " << mIdx << nl
+                        << " My indices: " << myIdx << nl
+                        << abort(FatalError);
+                }
+            }
+
+            forAll(mP, pointI)
+            {
+                // Add a map entry
+                cMap.mapSlave
+                (
+                    coupleMap::POINT,
+                    mP[pointI],
+                    neiPoints[pointI]
+                );
+
+                cMap.mapMaster
+                (
+                    coupleMap::POINT,
+                    neiPoints[pointI],
+                    mP[pointI]
+                );
+            }
+        }
+
+        // Prepare point maps for globally shared points
+        const labelList& gpB = cMap.entityBuffer(coupleMap::POINT);
+
+        // Sanity check: Do global point buffer sizes match?
+        if ((mP.size() + gpB.size()) != nGlobal)
+        {
+            FatalErrorIn("void dynamicTopoFvMesh::buildProcessorCoupledMaps()")
+                << " Global point sizes don't match"
+                << " for processor: " << proc << nl
+                << " mP size: " << mP.size() << nl
+                << " gpB size: " << gpB.size() << nl
+                << " Total: " << (mP.size() + gpB.size()) << nl
+                << " nGlobal: " << nGlobal << nl
+                << abort(FatalError);
+        }
+
+        // Look at globalPoint addressing for its information.
+        const globalMeshData& gD = polyMesh::globalData();
+        const labelList& spA = gD.sharedPointAddr();
+        const labelList& spL = gD.sharedPointLabels();
+
+        forAll(gpB, pointI)
+        {
+            // Find my equivalent global point
+            label maIndex = findIndex(spA, gpB[pointI]);
+
+            // Add a map entry
+            cMap.mapSlave
+            (
+                coupleMap::POINT,
+                spL[maIndex],
+                (pointI + nShared)
+            );
+
+            cMap.mapMaster
+            (
+                coupleMap::POINT,
+                (pointI + nShared),
+                spL[maIndex]
+            );
+        }
+
+        if (debug > 1)
+        {
+            const boundBox& box = polyMesh::bounds();
+            const pointField& sPoints = rPM.subMesh().points_;
+            const Map<label>& pMap = cMap.entityMap(coupleMap::POINT);
+
+            // Fetch relative tolerance
+            scalar relTol = debug::tolerances("processorMatchTol", 1e-4);
+
+            // Compute tolerance
+            scalar tol = relTol * box.mag();
+
+            forAllConstIter(Map<label>, pMap, pIter)
+            {
+                scalar dist = mag(points_[pIter.key()] - sPoints[pIter()]);
+
+                if (dist > tol)
+                {
+                    FatalErrorIn
+                    (
+                        "void dynamicTopoFvMesh::buildProcessorCoupledMaps()"
+                    )
+                        << " Failed to match point: " << pIter.key()
+                        << ": " << points_[pIter.key()]
+                        << " with point: " << pIter()
+                        << ": " << sPoints[pIter()] << nl
+                        << " Missed by: " << dist << nl
+                        << " Tolerance: " << tol << nl
+                        << abort(FatalError);
+                }
+            }
+        }
+
+        // Set up a comparison face.
+        face cFace(4);
+
+        // Now match all faces connected to master points.
+        if (nPrc.found(proc))
+        {
+            // Fetch a global faceList for the slave subMesh
+            const faceList& slaveFaces = rPM.subMesh().faces();
+
+            // This is an immediate neighbour.
+            label mStart = boundary[nPrc[proc]].start();
+            label mSize  = boundary[nPrc[proc]].size();
+
+            // Abbreviate for convenience
+            const dynamicTopoFvMesh& sMesh = rPM.subMesh();
+            const Map<label>& pMap = cMap.entityMap(coupleMap::POINT);
+            const Map<label>& eMap = cMap.entityMap(coupleMap::EDGE);
+            const Map<label>& fMap = cMap.entityMap(coupleMap::FACE);
+
+            // Fetch global pointFaces for the slave.
+            const labelListList& spF = rPM.subMesh().pointFaces();
+
+            // Match patch faces for both 2D and 3D.
+            for(label i = 0; i < mSize; i++)
+            {
+                // Fetch the global face index
+                label mfIndex = (mStart + i);
+
+                if (fMap.found(mfIndex))
+                {
+                    continue;
+                }
+
+                const face& mFace = faces_[mfIndex];
+
+                // Configure the face for comparison.
+                forAll(mFace, pointI)
+                {
+                    cFace[pointI] = pMap[mFace[pointI]];
+                }
+
+                // Fetch pointFaces for the zeroth point.
+                const labelList& spFaces = spF[cFace[0]];
+
+                if (twoDMesh_)
+                {
+                    bool matched = false;
+
+                    forAll(spFaces, faceJ)
+                    {
+                        // Fetch the global face index
+                        label sfIndex = spFaces[faceJ];
+
+                        const face& sFace = slaveFaces[sfIndex];
+
+                        if (face::compare(cFace, sFace))
+                        {
+                            // Found the slave. Add a map entry
+                            cMap.mapSlave
+                            (
+                                coupleMap::FACE,
+                                mfIndex,
+                                sfIndex
+                            );
+
+                            cMap.mapMaster
+                            (
+                                coupleMap::FACE,
+                                sfIndex,
+                                mfIndex
+                            );
+
+                            matched = true;
+
+                            break;
+                        }
+                    }
+
+                    if (!matched)
+                    {
+                        unMatchedFaces.insert(mfIndex);
+
+                        continue;
+                    }
+                }
+                else
+                {
+                    label sFaceIndex = -1;
+
+                    forAll(spFaces, faceJ)
+                    {
+                        // Fetch the global face index
+                        label sfIndex = spFaces[faceJ];
+
+                        const face& sFace = slaveFaces[sfIndex];
+
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(cFace[0], cFace[1], cFace[2]),
+                                triFace(sFace[0], sFace[1], sFace[2])
+                            )
+                        )
+                        {
+                            // Found the slave. Add a map entry
+                            cMap.mapSlave
+                            (
+                                coupleMap::FACE,
+                                mfIndex,
+                                sfIndex
+                            );
+
+                            cMap.mapMaster
+                            (
+                                coupleMap::FACE,
+                                sfIndex,
+                                mfIndex
+                            );
+
+                            sFaceIndex = sfIndex;
+
+                            break;
+                        }
+                    }
+
+                    if (sFaceIndex == -1)
+                    {
+                        unMatchedFaces.insert(mfIndex);
+
+                        continue;
+                    }
+
+                    // Match all edges on this face as well.
+                    const labelList& mfEdges = faceEdges_[mfIndex];
+                    const labelList& sfEdges = sMesh.faceEdges_[sFaceIndex];
+
+                    forAll(mfEdges, edgeI)
+                    {
+                        if (eMap.found(mfEdges[edgeI]))
+                        {
+                            continue;
+                        }
+
+                        const edge& mEdge = edges_[mfEdges[edgeI]];
+
+                        // Configure a comparison edge.
+                        edge cEdge(pMap[mEdge[0]], pMap[mEdge[1]]);
+
+                        bool matchedEdge = false;
+
+                        forAll(sfEdges, edgeJ)
+                        {
+                            const edge& sEdge =
+                            (
+                                sMesh.edges_[sfEdges[edgeJ]]
+                            );
+
+                            if (cEdge == sEdge)
+                            {
+                                // Found the slave. Add a map entry
+                                cMap.mapSlave
+                                (
+                                    coupleMap::EDGE,
+                                    mfEdges[edgeI],
+                                    sfEdges[edgeJ]
+                                );
+
+                                cMap.mapMaster
+                                (
+                                    coupleMap::EDGE,
+                                    sfEdges[edgeJ],
+                                    mfEdges[edgeI]
+                                );
+
+                                matchedEdge = true;
+
+                                break;
+                            }
+                        }
+
+                        if (!matchedEdge)
+                        {
+                            // Write out the edge
+                            writeVTK("mEdge", mfEdges[edgeI], 1);
+
+                            FatalErrorIn
+                            (
+                                "void dynamicTopoFvMesh::"
+                                "buildProcessorCoupledMaps()"
+                            )
+                                << " Failed to match edge: "
+                                << mfEdges[edgeI] << ": "
+                                << mEdge << nl
+                                << " cEdge: " << cEdge
+                                << " for processor: " << proc
+                                << abort(FatalError);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Attempt to match other edges in 3D, provided any common ones exist.
+        //  - This will handle point-only coupling situations for edges.
+        if (!twoDMesh_)
+        {
+            // Fetch Maps for this processor
+            const Map<label>& edgeMap = cMap.entityMap(coupleMap::EDGE);
+            const Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+
+            forAllConstIter(Map<label>, pointMap, pIter)
+            {
+                const labelList& pEdges = pointEdges_[pIter.key()];
+
+                forAll(pEdges, edgeI)
+                {
+                    const label eIndex = pEdges[edgeI];
+
+                    // Only pick boundary edges
+                    if (whichEdgePatch(eIndex) == -1)
+                    {
+                        continue;
+                    }
+
+                    // Skip mapped edges
+                    if (edgeMap.found(eIndex))
+                    {
+                        continue;
+                    }
+
+                    const edge& eCheck = edges_[eIndex];
+
+                    // Check if a map exists for the other point
+                    label sIndex =
+                    (
+                        cMap.findSlave
+                        (
+                            coupleMap::POINT,
+                            eCheck.otherVertex(pIter.key())
+                        )
+                    );
+
+                    if (sIndex > -1)
+                    {
+                        const dynamicTopoFvMesh& mesh = rPM.subMesh();
+
+                        // Configure a check edge
+                        edge cEdge(sIndex, pIter());
+
+                        const labelList& spEdges = mesh.pointEdges_[sIndex];
+
+                        forAll(spEdges, edgeJ)
+                        {
+                            const edge& sEdge = mesh.edges_[spEdges[edgeJ]];
+
+                            if (sEdge == cEdge)
+                            {
+                                // Found the slave. Add a map entry
+                                cMap.mapSlave
+                                (
+                                    coupleMap::EDGE,
+                                    eIndex,
+                                    spEdges[edgeJ]
+                                );
+
+                                cMap.mapMaster
+                                (
+                                    coupleMap::EDGE,
+                                    spEdges[edgeJ],
+                                    eIndex
+                                );
+
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (unMatchedFaces.size())
+        {
+            // Write out the face
+            writeVTK("mFaces", unMatchedFaces.toc(), 2);
+
+            FatalErrorIn
+            (
+                "void dynamicTopoFvMesh::buildProcessorCoupledMaps()"
+            )
+                << " Unmatched faces were found for processor: " << proc
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// Introduce a new processor patch to the mesh
+label dynamicTopoFvMesh::createProcessorPatch(const label proc)
+{
+    if (!Pstream::parRun())
+    {
+        return -2;
+    }
+
+    // Get the new patch index,
+    // and increment the number of patches
+    label patchID = nPatches_++;
+
+    // Find index in list of processors
+    label pI = findIndex(procIndices_, proc);
+
+    // Set the new patch index in patchMaps
+    if (isSubMesh_)
+    {
+        if (pI == -1)
+        {
+            pI = procIndices_.size();
+
+            procIndices_.setSize(pI + 1);
+            sendMeshes_.setSize(pI + 1);
+        }
+
+        // Create a basic entry
+        procIndices_[pI] = proc;
+
+        sendMeshes_.set
+        (
+            pI,
+            new coupledInfo
+            (
+                *this,               // Reference to this mesh
+                twoDMesh_,           // 2D or 3D
+                false,               // Not local
+                true,                // Sent to neighbour
+                patchID,             // Patch index
+                proc,                // Master index
+                -1                   // Slave index
+            )
+        );
+    }
+    else
+    {
+        if (pI == -1)
+        {
+            Pout<< " Could not find index for processor: " << proc
+                << " in indices: " << procIndices_
+                << abort(FatalError);
+        }
+
+        sendMeshes_[pI].map().patchIndex() = patchID;
+        recvMeshes_[pI].map().patchIndex() = patchID;
+    }
+
+    // Size up patches, and copy old information
+    label prevPatchID = patchID - 1;
+
+    patchSizes_.setSize(nPatches_, 0);
+    oldPatchSizes_.setSize(nPatches_, 0);
+
+    patchStarts_.setSize
+    (
+        nPatches_,
+        patchStarts_[prevPatchID] + patchSizes_[prevPatchID]
+    );
+    oldPatchStarts_.setSize
+    (
+        nPatches_,
+        oldPatchStarts_[prevPatchID] + oldPatchSizes_[prevPatchID]
+    );
+
+    edgePatchSizes_.setSize(nPatches_, 0);
+    oldEdgePatchSizes_.setSize(nPatches_, 0);
+
+    edgePatchStarts_.setSize
+    (
+        nPatches_,
+        edgePatchStarts_[prevPatchID] + edgePatchSizes_[prevPatchID]
+    );
+    oldEdgePatchStarts_.setSize
+    (
+        nPatches_,
+        oldEdgePatchStarts_[prevPatchID] + oldEdgePatchSizes_[prevPatchID]
+    );
+
+    patchNMeshPoints_.setSize(nPatches_, 0);
+    oldPatchNMeshPoints_.setSize(nPatches_, 0);
+
+    if (debug)
+    {
+        Pout<< " dynamicTopoFvMesh::createProcessorPatch :"
+            << " Created new patch for processor: " << proc << nl
+            << " On subMesh: " << Switch::asText(isSubMesh_) << nl
+            << " pI: " << pI << nl
+            << " patchID: " << patchID << nl
+            << " patchStarts: " << patchStarts_ << nl
+            << " patchSizes: " << patchSizes_ << nl
+            << endl;
+    }
+
+    // Return the new patch index
+    return patchID;
+}
+
+
+// If a patch is of processor type, get the neighbouring processor ID
+label dynamicTopoFvMesh::getNeighbourProcessor(const label patch) const
+{
+    if (!Pstream::parRun())
+    {
+        return -1;
+    }
+
+    label neiProcNo = -1;
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    if (patch == -1)
+    {
+        return -1;
+    }
+    else
+    if (patch < boundary.size())
+    {
+        if (isA<processorPolyPatch>(boundary[patch]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[patch])
+            );
+
+            // Set the neighbour processor ID
+            neiProcNo = pp.neighbProcNo();
+        }
+    }
+    else
+    {
+        // New processor patch
+
+        // Find the neighbour processor ID
+        forAll(procIndices_, pI)
+        {
+            label patchID = sendMeshes_[pI].map().patchIndex();
+
+            if (patch == patchID)
+            {
+                neiProcNo = procIndices_[pI];
+                break;
+            }
+        }
+
+        if (neiProcNo == -1)
+        {
+            // An index should have been defined by now
+            Pout<< " Patch: " << patch
+                << " was not defined on patch subMeshes."
+                << abort(FatalError);
+        }
+    }
+
+    return neiProcNo;
+}
+
+
+// If the number of patches have changed during run-time,
+// reset boundaries with new processor patches
+void dynamicTopoFvMesh::resetBoundaries()
+{
+    // Prepare a new list of patches
+    List<polyPatch*> patches(nPatches_);
+
+    // Fetch reference to existing boundary
+    // - The removeBoundary member merely resets
+    //   boundary size, so this reference is safe
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Copy all existing patches first
+    for (label patchI = 0; patchI < boundaryMesh().size(); patchI++)
+    {
+        // Clone the patch
+        patches[patchI] = boundary[patchI].clone(boundary).ptr();
+    }
+
+    // Create new processor patches
+    for (label patchI = boundaryMesh().size(); patchI < nPatches_; patchI++)
+    {
+        // Make a temporary dictionary for patch construction
+        dictionary patchDict;
+
+        // Back out the neighbour processor ID
+        label neiProcNo = getNeighbourProcessor(patchI);
+
+        // Add relevant info
+        patchDict.add("type", "processor");
+        patchDict.add("startFace", patchStarts_[patchI]);
+        patchDict.add("nFaces", patchSizes_[patchI]);
+        patchDict.add("myProcNo", Pstream::myProcNo());
+        patchDict.add("neighbProcNo", neiProcNo);
+
+        // Set the pointer
+        patches[patchI] =
+        (
+            polyPatch::New
+            (
+                "procBoundary"
+              + Foam::name(Pstream::myProcNo())
+              + "to"
+              + Foam::name(neiProcNo),
+                patchDict,
+                patchI,
+                boundary
+            ).ptr()
+        );
+    }
+
+    // Remove the old boundary
+    fvMesh::removeFvBoundary();
+
+    // Add patches, but don't calculate geometry, etc
+    fvMesh::addFvPatches(patches, false);
+}
+
+
+// Initialize subMesh field transfers for mapping
+void dynamicTopoFvMesh::initFieldTransfers
+(
+    wordList& types,
+    List<wordList>& names,
+    List<List<char> >& sendBuffer,
+    List<List<char> >& recvBuffer
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< " void dynamicTopoFvMesh::initFieldTransfers() :"
+            << " Initializing subMesh field transfers."
+            << endl;
+    }
+
+    // Clear out mesh geometry, since those
+    // are to be wiped out after topo-changes anyway.
+    fvMesh::clearOut();
+    polyMesh::resetMotion();
+
+    // Size up wordLists
+    //  - Five templated volFields
+    //  - Five templated surfaceFields
+    //  - One scalar volume gradient (conservative mapping)
+    //  - One vector volume gradient (conservative mapping)
+    names.setSize(12);
+    types.setSize(12);
+
+    // Fill in field-types
+    types[0] = volScalarField::typeName;
+    types[1] = volVectorField::typeName;
+    types[2] = volSphericalTensorField::typeName;
+    types[3] = volSymmTensorField::typeName;
+    types[4] = volTensorField::typeName;
+
+    types[5] = surfaceScalarField::typeName;
+    types[6] = surfaceVectorField::typeName;
+    types[7] = surfaceSphericalTensorField::typeName;
+    types[8] = surfaceSymmTensorField::typeName;
+    types[9] = surfaceTensorField::typeName;
+
+    types[10] = "grad(" + volScalarField::typeName + ')';
+    types[11] = "grad(" + volVectorField::typeName + ')';
+
+    // Send / recv buffers for field names
+    List<char> fieldNameSendBuffer, fieldNameRecvBuffer;
+
+    // Fetch reference to mapper
+    const topoMapper& fieldMapper = mapper_();
+
+    if (Pstream::master())
+    {
+        PtrList<OStringStream> fieldNameStream(1);
+
+        // Set the stream
+        fieldNameStream.set(0, new OStringStream(IOstream::BINARY));
+
+        // Alias for convenience
+        OStringStream& fNStream = fieldNameStream[0];
+
+        // Fetch field-names by type
+        for (label typeI = 0; typeI < 10; typeI++)
+        {
+            // Get all fields of type
+            names[typeI] = objectRegistry::names(types[typeI]);
+        }
+
+        // Fetch scalar gradient names
+        names[10] = fieldMapper.scalarGrads();
+
+        // Fetch vector gradient names
+        names[11] = fieldMapper.vectorGrads();
+
+        // Send field names to Ostream
+        fNStream << names;
+
+        // Size up buffers and fill contents
+        string contents = fNStream.str();
+        const char* ptr = contents.data();
+
+        fieldNameSendBuffer.setSize(contents.size());
+
+        forAll(fieldNameSendBuffer, i)
+        {
+            fieldNameSendBuffer[i] = *ptr++;
+        }
+
+        // Clear the stream
+        fieldNameStream.set(0, NULL);
+
+        if (debug > 4)
+        {
+            Info<< " Registered fields: " << names << endl;
+        }
+
+        // Send names to slaves
+        for (label proc = 1; proc < Pstream::nProcs(); proc++)
+        {
+            // Send buffer to processor
+            meshOps::pWrite(proc, fieldNameSendBuffer.size());
+            meshOps::pWrite(proc, fieldNameSendBuffer);
+        }
+    }
+    else
+    {
+        // Receive names from master
+        label recvBufferSize = -1;
+        meshOps::pRead(Pstream::masterNo(), recvBufferSize);
+
+        // Size up buffer and schedule receive
+        fieldNameRecvBuffer.setSize(recvBufferSize);
+        meshOps::pRead(Pstream::masterNo(), fieldNameRecvBuffer);
+    }
+
+    // Wait for transfers to complete
+    meshOps::waitForBuffers();
+
+    // Convert names from stringStream
+    if (!Pstream::master())
+    {
+        string contents
+        (
+            fieldNameRecvBuffer.begin(),
+            fieldNameRecvBuffer.size()
+        );
+
+        // Set the stream
+        IStringStream fieldNameStream(contents, IOstream::BINARY);
+
+        // Get names from stream
+        fieldNameStream >> names;
+    }
+
+    label nProcs = procIndices_.size();
+
+    // Size up buffers
+    sendBuffer.setSize(nProcs);
+    recvBuffer.setSize(nProcs);
+
+    // Size up the send stringStream
+    PtrList<OStringStream> stream(nProcs);
+
+    // Now fill in subMesh fields
+    forAll(procIndices_, pI)
+    {
+        label proc = procIndices_[pI];
+
+        const coupledInfo& cInfo = sendMeshes_[pI];
+
+        // Initialize stream
+        stream.set(pI, new OStringStream(IOstream::BINARY));
+
+        // Subset volFields to stream
+        cInfo.mapVolField<scalar>(names[0], types[0], stream[pI]);
+        cInfo.mapVolField<vector>(names[1], types[1], stream[pI]);
+        cInfo.mapVolField<sphericalTensor>(names[2], types[2], stream[pI]);
+        cInfo.mapVolField<symmTensor>(names[3], types[3], stream[pI]);
+        cInfo.mapVolField<tensor>(names[4], types[4], stream[pI]);
+
+        // Subset surfaceFields to stream
+        cInfo.mapSurfaceField<scalar>(names[5], types[5], stream[pI]);
+        cInfo.mapSurfaceField<vector>(names[6], types[6], stream[pI]);
+        cInfo.mapSurfaceField<sphericalTensor>(names[7], types[7], stream[pI]);
+        cInfo.mapSurfaceField<symmTensor>(names[8], types[8], stream[pI]);
+        cInfo.mapSurfaceField<tensor>(names[9], types[9], stream[pI]);
+
+        // Subset scalar gradients to stream
+        stream[pI]
+            << types[10] << token::NL
+            << token::BEGIN_BLOCK << token::NL;
+
+        forAll(names[10], i)
+        {
+            tmp<volVectorField> tvvfFld =
+            (
+                cInfo.subSetVolField
+                (
+                    fieldMapper.gradient<volVectorField>
+                    (
+                        names[10][i]
+                    )
+                )
+            );
+
+            // Send field through stream
+            stream[pI]
+                << names[10][i]
+                << token::NL << token::BEGIN_BLOCK
+                << tvvfFld
+                << token::NL << token::END_BLOCK
+                << token::NL;
+        }
+
+        stream[pI]
+            << token::END_BLOCK << token::NL;
+
+        // Subset vector gradients to stream
+        stream[pI]
+            << types[11] << token::NL
+            << token::BEGIN_BLOCK << token::NL;
+
+        forAll(names[11], i)
+        {
+            tmp<volTensorField> tvtfFld =
+            (
+                cInfo.subSetVolField
+                (
+                    fieldMapper.gradient<volTensorField>
+                    (
+                        names[11][i]
+                    )
+                )
+            );
+
+            // Send field through stream
+            stream[pI]
+                << names[11][i]
+                << token::NL << token::BEGIN_BLOCK
+                << tvtfFld
+                << token::NL << token::END_BLOCK
+                << token::NL;
+        }
+
+        stream[pI]
+            << token::END_BLOCK << token::NL;
+
+        // Size up buffers and fill contents
+        string contents = stream[pI].str();
+        const char* ptr = contents.data();
+
+        sendBuffer[pI].setSize(contents.size());
+
+        forAll(sendBuffer[pI], i)
+        {
+            sendBuffer[pI][i] = *ptr++;
+        }
+
+        // Clear the stream
+        stream.set(pI, NULL);
+
+        // Send buffer to processor
+        meshOps::pWrite(proc, sendBuffer[pI].size());
+        meshOps::pWrite(proc, sendBuffer[pI]);
+
+        // Receive buffer from processor
+        label recvBufferSize = -1;
+        meshOps::pRead(proc, recvBufferSize);
+
+        // Size up buffer and schedule receive
+        recvBuffer[pI].setSize(recvBufferSize);
+        meshOps::pRead(proc, recvBuffer[pI]);
+    }
+
+    // We won't wait for all transfers to complete for the moment.
+    // Meanwhile, do some other useful work, if possible.
+}
+
+
+// Synchronize field transfers for mapping
+void dynamicTopoFvMesh::syncFieldTransfers
+(
+    wordList& types,
+    List<wordList>& names,
+    List<List<char> >& recvBuffer
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< " void dynamicTopoFvMesh::syncFieldTransfers() :"
+            << " Synchronizing subMesh field transfers."
+            << endl;
+    }
+
+    // Wait for all transfers to complete.
+    meshOps::waitForBuffers();
+
+    label nProcs = procIndices_.size();
+
+    // Size up stringStream
+    PtrList<IStringStream> stream(nProcs);
+
+    // Size up field PtrLists
+
+    // Volume Fields
+    List<PtrList<volScalarField> > vsF(nProcs);
+    List<PtrList<volVectorField> > vvF(nProcs);
+    List<PtrList<volSphericalTensorField> > vsptF(nProcs);
+    List<PtrList<volSymmTensorField> > vsytF(nProcs);
+    List<PtrList<volTensorField> > vtF(nProcs);
+
+    // Surface fields
+    List<PtrList<surfaceScalarField> > ssF(nProcs);
+    List<PtrList<surfaceVectorField> > svF(nProcs);
+    List<PtrList<surfaceSphericalTensorField> > ssptF(nProcs);
+    List<PtrList<surfaceSymmTensorField> > ssytF(nProcs);
+    List<PtrList<surfaceTensorField> > stF(nProcs);
+
+    // Gradients
+    List<PtrList<volVectorField> > vgsF(nProcs);
+    List<PtrList<volTensorField> > vgvF(nProcs);
+
+    // Geometry
+    List<PtrList<volVectorField> > vC(nProcs);
+    List<PtrList<surfaceScalarField> > sSf(nProcs);
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    // Determine number of physical (non-processor) patches
+    label nPhysical = 0;
+
+    forAll(boundary, patchI)
+    {
+        if (isA<processorPolyPatch>(boundary[patchI]))
+        {
+            continue;
+        }
+
+        nPhysical++;
+    }
+
+    // Keep track of extra / total entities
+    label nTotalCells = nOldCells_, nTotalIntFaces = nOldInternalFaces_;
+    labelList nTotalPatchFaces(SubList<label>(oldPatchSizes_, nPhysical));
+
+    // Allocate reverse maps
+    List<labelList> irvMaps(nProcs), irsMaps(nProcs);
+    List<labelListList> brMaps(nProcs, labelListList(nPhysical));
+
+    forAll(procIndices_, pI)
+    {
+        const coupledInfo& cInfo = recvMeshes_[pI];
+
+        // Convert buffer to string
+        string contents(recvBuffer[pI].begin(), recvBuffer[pI].size());
+
+        // Initialize stream
+        stream.set(pI, new IStringStream(contents, IOstream::BINARY));
+
+        // Construct dictionary from stream
+        dictionary dict(stream[pI]);
+
+        // Set field pointers
+        cInfo.setField(names[0], dict.subDict(types[0]), vsF[pI]);
+        cInfo.setField(names[1], dict.subDict(types[1]), vvF[pI]);
+        cInfo.setField(names[2], dict.subDict(types[2]), vsptF[pI]);
+        cInfo.setField(names[3], dict.subDict(types[3]), vsytF[pI]);
+        cInfo.setField(names[4], dict.subDict(types[4]), vtF[pI]);
+
+        cInfo.setField(names[5], dict.subDict(types[5]), ssF[pI]);
+        cInfo.setField(names[6], dict.subDict(types[6]), svF[pI]);
+        cInfo.setField(names[7], dict.subDict(types[7]), ssptF[pI]);
+        cInfo.setField(names[8], dict.subDict(types[8]), ssytF[pI]);
+        cInfo.setField(names[9], dict.subDict(types[9]), stF[pI]);
+
+        cInfo.setField(names[10], dict.subDict(types[10]), vgsF[pI]);
+        cInfo.setField(names[11], dict.subDict(types[11]), vgvF[pI]);
+
+        // Set centres
+        cInfo.setCentres(vC[pI]);
+
+        // Count the number of additional entities
+        const coupleMap& cMap = cInfo.map();
+
+        // Fetch size from subMesh
+        label nCells = cMap.nEntities(coupleMap::CELL);
+        label nIntFaces = cMap.nEntities(coupleMap::INTERNAL_FACE);
+
+        // Set rmap for this processor
+        irvMaps[pI] = (labelField(identity(nCells)) + nTotalCells);
+        irsMaps[pI] = (labelField(identity(nIntFaces)) + nTotalIntFaces);
+
+        // Update count
+        nTotalCells += nCells;
+        nTotalIntFaces += nIntFaces;
+
+        // Fetch patch sizes from subMesh
+        const labelList& nPatchFaces =
+        (
+            cMap.entityBuffer(coupleMap::FACE_SIZES)
+        );
+
+        // Loop over physical patches
+        forAll(nTotalPatchFaces, patchI)
+        {
+            // Fetch patch size from subMesh
+            label nFaces = nPatchFaces[patchI];
+
+            // Set rmap for this patch
+            brMaps[pI][patchI] =
+            (
+                labelField(identity(nFaces))
+              + nTotalPatchFaces[patchI]
+            );
+
+            // Update patch-face count
+            nTotalPatchFaces[patchI] += nFaces;
+        }
+    }
+
+    // Prepare internal mappers
+    labelList cellAddressing(nTotalCells, 0);
+    labelList faceAddressing(nTotalIntFaces, 0);
+
+    // Set identity map for first nCells,
+    // and map from cell[0] for the rest
+    for (label i = 0; i < nOldCells_; i++)
+    {
+        cellAddressing[i] = i;
+    }
+
+    // Set identity map for first nIntFaces,
+    // and map from face[0] for the rest
+    for (label i = 0; i < nOldInternalFaces_; i++)
+    {
+        faceAddressing[i] = i;
+    }
+
+    coupledInfo::subMeshMapper vMap
+    (
+        nOldCells_,
+        cellAddressing
+    );
+
+    coupledInfo::subMeshMapper sMap
+    (
+        nOldInternalFaces_,
+        faceAddressing
+    );
+
+    // Prepare boundary mappers
+    labelListList patchAddressing(nPhysical);
+    PtrList<coupledInfo::subMeshMapper> bMap(nPhysical);
+
+    forAll(bMap, patchI)
+    {
+        // Prepare patch mappers
+        patchAddressing[patchI].setSize(nTotalPatchFaces[patchI], 0);
+
+        // Set identity map for first nPatchFaces,
+        // and map from patch-face[0] for the rest
+        for (label i = 0; i < oldPatchSizes_[patchI]; i++)
+        {
+            patchAddressing[patchI][i] = i;
+        }
+
+        // Set the boundary mapper pointer
+        bMap.set
+        (
+            patchI,
+            new coupledInfo::subMeshMapper
+            (
+                oldPatchSizes_[patchI],
+                patchAddressing[patchI]
+            )
+        );
+    }
+
+    // Loop through all volFields and re-size
+    // to accomodate additional cells / faces
+    coupledInfo::resizeMap(names[0], *this, vMap, irvMaps, bMap, brMaps, vsF);
+    coupledInfo::resizeMap(names[1], *this, vMap, irvMaps, bMap, brMaps, vvF);
+    coupledInfo::resizeMap(names[2], *this, vMap, irvMaps, bMap, brMaps, vsptF);
+    coupledInfo::resizeMap(names[3], *this, vMap, irvMaps, bMap, brMaps, vsytF);
+    coupledInfo::resizeMap(names[4], *this, vMap, irvMaps, bMap, brMaps, vtF);
+
+    coupledInfo::resizeMap(names[5], *this, sMap, irsMaps, bMap, brMaps, ssF);
+    coupledInfo::resizeMap(names[6], *this, sMap, irsMaps, bMap, brMaps, svF);
+    coupledInfo::resizeMap(names[7], *this, sMap, irsMaps, bMap, brMaps, ssptF);
+    coupledInfo::resizeMap(names[8], *this, sMap, irsMaps, bMap, brMaps, ssytF);
+    coupledInfo::resizeMap(names[9], *this, sMap, irsMaps, bMap, brMaps, stF);
+
+    // Fetch reference to mapper
+    const topoMapper& fieldMapper = mapper_();
+
+    // Map gradient fields
+    forAll(names[10], i)
+    {
+        volVectorField& sGrad =
+        (
+            fieldMapper.gradient<volVectorField>(names[10][i])
+        );
+
+        // Map the field
+        coupledInfo::resizeMap(i, vMap, irvMaps, bMap, brMaps, vgsF, sGrad);
+    }
+
+    forAll(names[11], i)
+    {
+        volTensorField& vGrad =
+        (
+            fieldMapper.gradient<volTensorField>(names[11][i])
+        );
+
+        // Map the field
+        coupledInfo::resizeMap(i, vMap, irvMaps, bMap, brMaps, vgvF, vGrad);
+    }
+
+    // Map stored geometry
+    volVectorField& mapC = fieldMapper.volCentres();
+
+    // Map geometry fields
+    coupledInfo::resizeMap(0, vMap, irvMaps, bMap, brMaps, vC, mapC);
+}
+
+
+// Initialize coupled boundary ordering
+// - Assumes that faces_ and points_ are consistent
+// - Assumes that patchStarts_ and patchSizes_ are consistent
+void dynamicTopoFvMesh::initCoupledBoundaryOrdering
+(
+    List<pointField>& centres,
+    List<pointField>& anchors
+) const
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    for (label pI = 0; pI < nPatches_; pI++)
+    {
+        label neiProcNo = getNeighbourProcessor(pI);
+
+        if (neiProcNo == -1)
+        {
+            continue;
+        }
+
+        // Check if this is a master processor patch.
+        label start = patchStarts_[pI];
+        label size = patchSizes_[pI];
+
+        // Prepare centres and anchors
+        centres[pI].setSize(size, vector::zero);
+        anchors[pI].setSize(size, vector::zero);
+
+        if (Pstream::myProcNo() < neiProcNo)
+        {
+            forAll(centres[pI], fI)
+            {
+                centres[pI][fI] = faces_[fI + start].centre(points_);
+                anchors[pI][fI] = points_[faces_[fI + start][0]];
+            }
+
+            {
+                if (debug > 3)
+                {
+                    Pout<< "Sending to: " << neiProcNo
+                        << " nCentres: " << size << endl;
+
+                    // Write out my centres to disk
+                    meshOps::writeVTK
+                    (
+                        (*this),
+                        "centres_"
+                      + Foam::name(Pstream::myProcNo())
+                      + "to"
+                      + Foam::name(neiProcNo),
+                        size, size, size,
+                        centres[pI]
+                    );
+                }
+
+                // Ensure that we're sending the right size
+                meshOps::pWrite(neiProcNo, size);
+            }
+
+            // Send information to neighbour
+            meshOps::pWrite(neiProcNo, centres[pI]);
+            meshOps::pWrite(neiProcNo, anchors[pI]);
+        }
+        else
+        {
+            {
+                label nEntities = -1;
+
+                // Ensure that we're receiving the right size
+                meshOps::pRead(neiProcNo, nEntities);
+
+                if (debug > 3)
+                {
+                    Pout<< " Recving from: " << neiProcNo
+                        << " nCentres: " << size << endl;
+                }
+
+                if (nEntities != size)
+                {
+                    // Set the size to what we're receiving
+                    centres[pI].setSize(nEntities, vector::zero);
+                    anchors[pI].setSize(nEntities, vector::zero);
+
+                    // Issue a warning now, and let
+                    // syncCoupledBoundaryOrdering fail later
+                    WarningIn
+                    (
+                        "void dynamicTopoFvMesh::"
+                        "initCoupledBoundaryOrdering() const"
+                    )
+                        << "Incorrect send / recv sizes: " << nl
+                        << " nEntities: " << nEntities << nl
+                        << " size: " << size << nl
+                        << endl;
+                }
+            }
+
+            // Schedule receive from neighbour
+            meshOps::pRead(neiProcNo, centres[pI]);
+            meshOps::pRead(neiProcNo, anchors[pI]);
+        }
+    }
+}
+
+
+// Synchronize coupled boundary ordering
+bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
+(
+    List<pointField>& centres,
+    List<pointField>& anchors,
+    labelListList& patchMaps,
+    labelListList& rotations
+) const
+{
+    bool anyChange = false, failedPatchMatch = false;
+
+    // Fetch tolerance
+    scalar matchTol = Foam::debug::tolerances("patchFaceMatchTol", 1e-4);
+
+    // Calculate centres and tolerances for any slave patches
+    List<scalarField> slaveTols(nPatches_);
+    List<pointField> slaveCentres(nPatches_);
+
+    // Handle locally coupled patches
+    forAll(patchCoupling_, pI)
+    {
+        if (patchCoupling_(pI))
+        {
+            const coupleMap& cMap = patchCoupling_[pI].map();
+
+            label masterPatch = cMap.masterIndex();
+            label slavePatch = cMap.slaveIndex();
+
+            label mSize = patchSizes_[masterPatch];
+            label sSize = patchSizes_[slavePatch];
+
+            label mStart = patchStarts_[masterPatch];
+            label sStart = patchStarts_[slavePatch];
+
+            if (mSize != sSize)
+            {
+                Pout<< " Patch size mismatch: " << nl
+                    << "  mSize: " << mSize << nl
+                    << "  sSize: " << sSize << nl
+                    << "  mStart: " << mStart << nl
+                    << "  sStart: " << sStart << nl
+                    << "  master: " << masterPatch << nl
+                    << "  slave: " << slavePatch << nl
+                    << abort(FatalError);
+            }
+
+            // Calculate centres / tolerances
+            anchors[masterPatch].setSize(mSize, vector::zero);
+            centres[masterPatch].setSize(mSize, vector::zero);
+
+            slaveTols[slavePatch].setSize(sSize, 0.0);
+            slaveCentres[slavePatch].setSize(sSize, vector::zero);
+
+            for (label fI = 0; fI < mSize; fI++)
+            {
+                point& mfa = anchors[masterPatch][fI];
+                point& mfc = centres[masterPatch][fI];
+                point& sfc = slaveCentres[slavePatch][fI];
+
+                const face& mFace = faces_[fI + mStart];
+                const face& sFace = faces_[fI + sStart];
+
+                // Calculate anchor / centres
+                mfa = points_[mFace[0]];
+                mfc = mFace.centre(points_);
+                sfc = sFace.centre(points_);
+
+                scalar maxLen = -GREAT;
+
+                forAll(sFace, fpI)
+                {
+                    maxLen = max(maxLen, mag(points_[sFace[fpI]] - sfc));
+                }
+
+                slaveTols[slavePatch][fI] = matchTol*maxLen;
+            }
+
+            // For cyclics, additionally test for halves,
+            // and transform points as necessary.
+            labelList halfMap;
+
+            if (masterPatch == slavePatch)
+            {
+                scalar featureCos = 0.9;
+                label halfSize = (mSize / 2);
+                label half0Index = 0, half1Index = 0;
+
+                // Size up halfMap and slaveAnchors
+                halfMap.setSize(mSize, -1);
+
+                scalarField half1Tols(halfSize, 0.0);
+                vectorField half1Anchors(halfSize, vector::zero);
+
+                // Fetch face-normal for the first face
+                vector fhN = boundaryMesh()[masterPatch].faceAreas()[0];
+
+                // Normalize
+                fhN /= mag(fhN) + VSMALL;
+
+                // Fetch transform type
+                const cyclicPolyPatch& cyclicPatch =
+                (
+                    refCast<const cyclicPolyPatch>
+                    (
+                        boundaryMesh()[masterPatch]
+                    )
+                );
+
+                bool translate =
+                (
+                    cyclicPatch.transform()
+                 == cyclicPolyPatch::TRANSLATIONAL
+                );
+
+                for (label fI = 0; fI < mSize; fI++)
+                {
+                    const face& mFace = faces_[fI + mStart];
+
+                    // Compute normal
+                    vector fN = mFace.normal(points_);
+
+                    // Normalize
+                    fN /= mag(fN) + VSMALL;
+
+                    // Check which half this face belongs to...
+                    bool isFirstHalf = ((fhN & fN) > featureCos);
+
+                    if (isFirstHalf)
+                    {
+                        vector mA = anchors[masterPatch][fI];
+                        vector mC = centres[masterPatch][fI];
+
+                        // Set master anchor
+                        anchors[masterPatch][half0Index] = mA;
+
+                        // Transform master points
+                        if (translate)
+                        {
+                            mA += cyclicPatch.separationVector();
+                            mC += cyclicPatch.separationVector();
+                        }
+                        else
+                        {
+                            // Assume constant transform tensor
+                            mA = Foam::transform(cyclicPatch.transformT(0), mA);
+                            mC = Foam::transform(cyclicPatch.transformT(0), mC);
+                        }
+
+                        // Set the transformed anchor / centre
+                        half1Anchors[half0Index] = mA;
+                        centres[masterPatch][half0Index] = mC;
+                        half1Tols[half0Index] = slaveTols[masterPatch][fI];
+
+                        // Set halfMap
+                        halfMap[fI] = half0Index;
+
+                        half0Index++;
+                    }
+                    else
+                    {
+                        // Set the slave centre
+                        const scalar& sT = slaveTols[slavePatch][fI];
+                        const point& sC = slaveCentres[slavePatch][fI];
+
+                        // Duplicate slaveTols for first / second half
+                        slaveTols[slavePatch][half1Index] = sT;
+                        slaveCentres[slavePatch][half1Index] = sC;
+
+                        // Set halfMap
+                        halfMap[fI] = half1Index + halfSize;
+
+                        half1Index++;
+                    }
+                }
+
+                // Sanity check for halfSize
+                if (half0Index != halfSize || half1Index != halfSize)
+                {
+                    Pout<< " Master: " << masterPatch << nl
+                        << " Slave: " << slavePatch << nl
+                        << " half0Index: " << half0Index << nl
+                        << " half1Index: " << half1Index << nl
+                        << " halfSize: " << halfSize << nl
+                        << " failed to divide into halves."
+                        << abort(FatalError);
+                }
+
+                // Resize lists
+                centres[masterPatch].setSize(halfSize);
+                slaveCentres[slavePatch].setSize(halfSize);
+
+                // Set slave tols / anchors
+                forAll(half1Anchors, fI)
+                {
+                    slaveTols[masterPatch][fI + halfSize] = half1Tols[fI];
+                    anchors[masterPatch][fI + halfSize] = half1Anchors[fI];
+                }
+            }
+
+            // Fetch reference to slave map
+            labelList& patchMap = patchMaps[slavePatch];
+
+            // Try zero separation automatic matching
+            bool matchedAll =
+            (
+                matchPoints
+                (
+                    slaveCentres[slavePatch],
+                    centres[masterPatch],
+                    slaveTols[slavePatch],
+                    false,
+                    patchMap
+                )
+            );
+
+            // Write out master centres to disk
+            if (debug > 3 || !matchedAll)
+            {
+                meshOps::writeVTK
+                (
+                    (*this),
+                    "localMasterCentres_"
+                  + Foam::name(masterPatch)
+                  + '_'
+                  + Foam::name(slavePatch),
+                    mSize, mSize, mSize,
+                    centres[masterPatch]
+                );
+
+                meshOps::writeVTK
+                (
+                    (*this),
+                    "localSlaveCentres_"
+                  + Foam::name(masterPatch)
+                  + '_'
+                  + Foam::name(slavePatch),
+                    sSize, sSize, sSize,
+                    slaveCentres[slavePatch]
+                );
+
+                writeVTK
+                (
+                    "localMasterFaces_"
+                  + Foam::name(masterPatch)
+                  + '_'
+                  + Foam::name(slavePatch),
+                    identity(mSize) + mStart,
+                    2, false, true
+                );
+
+                writeVTK
+                (
+                    "localSlaveFaces_"
+                  + Foam::name(masterPatch)
+                  + '_'
+                  + Foam::name(slavePatch),
+                    identity(sSize) + sStart,
+                    2, false, true
+                );
+
+                if (!matchedAll)
+                {
+                    Pout<< " Master: " << masterPatch
+                        << " Slave: " << slavePatch
+                        << " mSize: " << mSize << " sSize: " << sSize
+                        << " failed on match for face centres."
+                        << endl;
+
+                    // Failed on match-for-all, so patchMaps
+                    // will be invalid. Bail out for now.
+                    failedPatchMatch = true;
+
+                    continue;
+                }
+            }
+
+            // Renumber patchMap for cyclics
+            if (masterPatch == slavePatch)
+            {
+                label halfSize = (mSize / 2);
+
+                forAll(halfMap, fI)
+                {
+                    if (halfMap[fI] >= halfSize)
+                    {
+                        halfMap[fI] =
+                        (
+                            patchMap[halfMap[fI] - halfSize]
+                          + halfSize
+                        );
+                    }
+                }
+
+                // Transfer map
+                patchMap.transfer(halfMap);
+            }
+
+            // Fetch reference to rotation map
+            labelList& rotation = rotations[slavePatch];
+
+            // Initialize rotation to zero
+            rotation.setSize(sSize, 0);
+
+            // Set rotation.
+            forAll(patchMap, oldFaceI)
+            {
+                label newFaceI = patchMap[oldFaceI];
+
+                const point& anchor = anchors[slavePatch][newFaceI];
+                const scalar& faceTol = slaveTols[slavePatch][oldFaceI];
+                const face& checkFace = faces_[sStart + oldFaceI];
+
+                label anchorFp = -1;
+                scalar minDSqr = GREAT;
+
+                forAll(checkFace, fpI)
+                {
+                    scalar dSqr = magSqr(anchor - points_[checkFace[fpI]]);
+
+                    if (dSqr < minDSqr)
+                    {
+                        minDSqr = dSqr;
+                        anchorFp = fpI;
+                    }
+                }
+
+                if (anchorFp == -1 || mag(minDSqr) > faceTol)
+                {
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "void dynamicTopoFvMesh::"
+                        "syncCoupledBoundaryOrdering\n"
+                        "(\n"
+                        "    List<pointField>& centres,\n"
+                        "    List<pointField>& anchors,\n"
+                        "    labelListList& patchMaps,\n"
+                        "    labelListList& rotations\n"
+                        ") const\n"
+                    )
+                        << "Cannot find anchor: " << anchor << nl
+                        << " Face: " << checkFace << nl
+                        << " Vertices: "
+                        << UIndirectList<point>(points_, checkFace) << nl
+                        << " on patch: " << slavePatch << nl
+                        << " faceTol: " << faceTol << nl
+                        << " newFaceI: " << newFaceI << nl
+                        << " oldFaceI: " << oldFaceI << nl
+                        << " mSize: " << mSize << nl
+                        << " sSize: " << sSize << nl
+                        << abort(FatalError);
+                }
+                else
+                {
+                    // Positive rotation
+                    //  - Set for old face. Will be rotated later
+                    //    during the shuffling stage
+                    rotation[oldFaceI] =
+                    (
+                        (checkFace.size() - anchorFp) % checkFace.size()
+                    );
+                }
+            }
+
+            // Set the flag
+            anyChange = true;
+        }
+    }
+
+    if (failedPatchMatch)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "void dynamicTopoFvMesh::"
+            "syncCoupledBoundaryOrdering\n"
+            "(\n"
+            "    List<pointField>& centres,\n"
+            "    List<pointField>& anchors,\n"
+            "    labelListList& patchMaps,\n"
+            "    labelListList& rotations\n"
+            ") const\n"
+        )
+            << " Matching for local patches failed. " << nl
+            << abort(FatalError);
+    }
+
+    if (!Pstream::parRun())
+    {
+        return anyChange;
+    }
+
+    for (label pI = 0; pI < nPatches_; pI++)
+    {
+        label neiProcNo = getNeighbourProcessor(pI);
+
+        if (neiProcNo == -1)
+        {
+            continue;
+        }
+
+        // Check if this is a slave processor patch.
+        label start = patchStarts_[pI];
+        label size = patchSizes_[pI];
+
+        if (Pstream::myProcNo() > neiProcNo)
+        {
+            slaveTols[pI].setSize(size, 0.0);
+            slaveCentres[pI].setSize(size, vector::zero);
+
+            forAll(slaveCentres[pI], fI)
+            {
+                point& fc = slaveCentres[pI][fI];
+
+                const face& checkFace = faces_[fI + start];
+
+                // Calculate centre
+                fc = checkFace.centre(points_);
+
+                scalar maxLen = -GREAT;
+
+                forAll(checkFace, fpI)
+                {
+                    maxLen = max(maxLen, mag(points_[checkFace[fpI]] - fc));
+                }
+
+                slaveTols[pI][fI] = matchTol*maxLen;
+            }
+
+            // Write out my centres to disk
+            if (debug > 3)
+            {
+                meshOps::writeVTK
+                (
+                    (*this),
+                    "slaveCentres_"
+                  + Foam::name(Pstream::myProcNo())
+                  + '_'
+                  + Foam::name(neiProcNo),
+                    size, size, size,
+                    slaveCentres[pI]
+                );
+            }
+        }
+    }
+
+    // Wait for transfers before continuing.
+    meshOps::waitForBuffers();
+
+    for (label pI = 0; pI < nPatches_; pI++)
+    {
+        label neiProcNo = getNeighbourProcessor(pI);
+
+        if (neiProcNo == -1)
+        {
+            continue;
+        }
+
+        // Check if this is a master processor patch.
+        labelList& patchMap = patchMaps[pI];
+        labelList& rotation = rotations[pI];
+
+        // Initialize map and rotation
+        patchMap.setSize(patchSizes_[pI], -1);
+        rotation.setSize(patchSizes_[pI], 0);
+
+        if (Pstream::myProcNo() < neiProcNo)
+        {
+            // Do nothing (i.e. identical mapping, zero rotation).
+            forAll(patchMap, pfI)
+            {
+                patchMap[pfI] = pfI;
+            }
+        }
+        else
+        {
+            // Try zero separation automatic matching
+            bool matchedAll =
+            (
+                matchPoints
+                (
+                    slaveCentres[pI],
+                    centres[pI],
+                    slaveTols[pI],
+                    false,
+                    patchMap
+                )
+            );
+
+            // Write out centres to disk
+            if (debug > 3 || !matchedAll)
+            {
+                label mSize = centres[pI].size();
+                label sSize = slaveCentres[pI].size();
+
+                meshOps::writeVTK
+                (
+                    (*this),
+                    "masterCentres_"
+                  + Foam::name(Pstream::myProcNo())
+                  + '_'
+                  + Foam::name(neiProcNo),
+                    mSize, mSize, mSize,
+                    centres[pI]
+                );
+
+                meshOps::writeVTK
+                (
+                    (*this),
+                    "slaveCentres_"
+                  + Foam::name(Pstream::myProcNo())
+                  + '_'
+                  + Foam::name(neiProcNo),
+                    sSize, sSize, sSize,
+                    slaveCentres[pI]
+                );
+
+                writeVTK
+                (
+                    "procPatchFaces_"
+                  + Foam::name(Pstream::myProcNo())
+                  + '_'
+                  + Foam::name(neiProcNo),
+                    identity(mSize) + patchStarts_[pI],
+                    2, false, true
+                );
+
+                if (!matchedAll)
+                {
+                    Pout<< " Patch: " << pI
+                        << " Processor: " << neiProcNo
+                        << " mSize: " << mSize << " sSize: " << sSize
+                        << " failed on match for face centres."
+                        << endl;
+
+                    // Failed on match-for-all, so patchMaps
+                    // will be invalid. Bail out for now.
+                    failedPatchMatch = true;
+
+                    continue;
+                }
+            }
+
+            label start = patchStarts_[pI];
+
+            // Set rotation.
+            forAll(patchMap, oldFaceI)
+            {
+                label newFaceI = patchMap[oldFaceI];
+
+                const point& anchor = anchors[pI][newFaceI];
+                const scalar& faceTol = slaveTols[pI][oldFaceI];
+                const face& checkFace = faces_[start + oldFaceI];
+
+                label anchorFp = -1;
+                scalar minDSqr = GREAT;
+
+                forAll(checkFace, fpI)
+                {
+                    scalar dSqr = magSqr(anchor - points_[checkFace[fpI]]);
+
+                    if (dSqr < minDSqr)
+                    {
+                        minDSqr = dSqr;
+                        anchorFp = fpI;
+                    }
+                }
+
+                if (anchorFp == -1 || mag(minDSqr) > faceTol)
+                {
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "void dynamicTopoFvMesh::"
+                        "syncCoupledBoundaryOrdering\n"
+                        "(\n"
+                        "    List<pointField>& centres,\n"
+                        "    List<pointField>& anchors,\n"
+                        "    labelListList& patchMaps,\n"
+                        "    labelListList& rotations\n"
+                        ") const\n"
+                    )
+                        << "Cannot find anchor: " << anchor << nl
+                        << " Face: " << checkFace << nl
+                        << " Vertices: "
+                        << UIndirectList<point>(points_, checkFace) << nl
+                        << " on patch: " << pI
+                        << " for processor: " << neiProcNo
+                        << abort(FatalError);
+                }
+                else
+                {
+                    // Positive rotation
+                    //  - Set for old face. Will be rotated later
+                    //    during the shuffling stage
+                    rotation[oldFaceI] =
+                    (
+                        (checkFace.size() - anchorFp) % checkFace.size()
+                    );
+                }
+            }
+
+            // Set the flag
+            anyChange = true;
+        }
+    }
+
+    // Reduce failures across processors
+    reduce(failedPatchMatch, orOp<bool>());
+
+    // Write out processor patch faces if a failure was encountered
+    if (failedPatchMatch)
+    {
+        for (label pI = 0; pI < nPatches_; pI++)
+        {
+            label neiProcNo = getNeighbourProcessor(pI);
+
+            if (neiProcNo == -1)
+            {
+                continue;
+            }
+
+            writeVTK
+            (
+                "patchFaces_"
+              + Foam::name(Pstream::myProcNo())
+              + '_'
+              + Foam::name(neiProcNo),
+                identity(patchSizes_[pI]) + patchStarts_[pI],
+                2
+            );
+        }
+
+        FatalErrorIn
+        (
+            "\n"
+            "void dynamicTopoFvMesh::"
+            "syncCoupledBoundaryOrdering\n"
+            "(\n"
+            "    List<pointField>& centres,\n"
+            "    List<pointField>& anchors,\n"
+            "    labelListList& patchMaps,\n"
+            "    labelListList& rotations\n"
+            ") const\n"
+        )
+            << " Matching for processor patches failed. " << nl
+            << " Patch faces written out to disk." << nl
+            << abort(FatalError);
+    }
+
+    return anyChange;
+}
+
+
+// Fill buffers with length-scale info
+// and exchange across processors.
+void dynamicTopoFvMesh::exchangeLengthBuffers()
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (!edgeRefinement_)
+    {
+        return;
+    }
+
+    forAll(procIndices_, pI)
+    {
+        coupledInfo& sPM = sendMeshes_[pI];
+        coupledInfo& rPM = recvMeshes_[pI];
+
+        const coupleMap& scMap = sPM.map();
+        const coupleMap& rcMap = rPM.map();
+
+        if (scMap.slaveIndex() == Pstream::myProcNo())
+        {
+            // Clear existing buffer
+            sPM.subMesh().lengthScale_.clear();
+
+            // Fill in buffers to send.
+            sPM.subMesh().lengthScale_.setSize
+            (
+                scMap.nEntities(coupleMap::CELL),
+                -1.0
+            );
+
+            Map<label>& cellMap = scMap.entityMap(coupleMap::CELL);
+
+            forAllIter(Map<label>, cellMap, cIter)
+            {
+                sPM.subMesh().lengthScale_[cIter.key()] = lengthScale_[cIter()];
+            }
+
+            meshOps::pWrite
+            (
+                scMap.masterIndex(),
+                sPM.subMesh().lengthScale_
+            );
+
+            if (debug > 4)
+            {
+                Pout<< "Sending to: "
+                    << scMap.masterIndex()
+                    << " nCells: "
+                    << scMap.nEntities(coupleMap::CELL)
+                    << endl;
+            }
+        }
+
+        if (rcMap.masterIndex() == Pstream::myProcNo())
+        {
+            // Clear existing buffer
+            rPM.subMesh().lengthScale_.clear();
+
+            // Schedule receipt from neighbour
+            rPM.subMesh().lengthScale_.setSize
+            (
+                rcMap.nEntities(coupleMap::CELL),
+                -1.0
+            );
+
+            // Schedule for receipt
+            meshOps::pRead
+            (
+                rcMap.slaveIndex(),
+                rPM.subMesh().lengthScale_
+            );
+
+            if (debug > 4)
+            {
+                Pout<< "Receiving from: "
+                    << rcMap.slaveIndex()
+                    << " nCells: "
+                    << rcMap.nEntities(coupleMap::CELL)
+                    << endl;
+            }
+        }
+    }
+
+    // Wait for transfers before continuing.
+    meshOps::waitForBuffers();
+
+    if (debug > 4)
+    {
+        forAll(procIndices_, pI)
+        {
+            const coupledInfo& rPM = recvMeshes_[pI];
+            const coupleMap& rcMap = rPM.map();
+
+            if (rcMap.masterIndex() == Pstream::myProcNo())
+            {
+                rPM.subMesh().writeVTK
+                (
+                    "lengthScale_" + Foam::name(rcMap.slaveIndex()),
+                    identity(rPM.subMesh().nCells()),
+                    3,
+                    false,
+                    false,
+                    rPM.subMesh().lengthScale_
+                );
+            }
+        }
+    }
+}
+
+
+// Implementing the fillTables operation for coupled edges
+bool dynamicTopoFvMesh::coupledFillTables
+(
+    const label eIndex,
+    scalar& minQuality,
+    labelList& m,
+    PtrList<scalarListList>& Q,
+    PtrList<labelListList>& K,
+    PtrList<labelListList>& triangulations
+) const
+{
+    bool success = false;
+
+    if (locallyCoupledEntity(eIndex))
+    {
+        // Fill tables for the slave edge.
+        label sI = -1;
+
+        // Determine the slave index.
+        forAll(patchCoupling_, patchI)
+        {
+            if (patchCoupling_(patchI))
+            {
+                const label edgeEnum  = coupleMap::EDGE;
+                const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                if ((sI = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                {
+                    break;
+                }
+            }
+        }
+
+        if (sI == -1)
+        {
+            FatalErrorIn
+            (
+                "\n"
+                "bool dynamicTopoFvMesh::coupledFillTables\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    const scalar minQuality,\n"
+                "    labelList& m,\n"
+                "    PtrList<scalarListList>& Q,\n"
+                "    PtrList<labelListList>& K,\n"
+                "    PtrList<labelListList>& triangulations\n"
+                ") const\n"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " Slave index not found for: " << nl
+                << " Edge: " << eIndex << nl
+                << abort(FatalError);
+        }
+
+        // Turn off switch temporarily.
+        unsetCoupledModification();
+
+        labelList hullV(10);
+
+        // Call fillTables for the slave edge.
+        success = fillTables(sI, minQuality, m, hullV, Q, K, triangulations, 1);
+
+        // Turn it back on.
+        setCoupledModification();
+    }
+    else
+    if (processorCoupledEntity(eIndex))
+    {
+        const edge& checkEdge = edges_[eIndex];
+        const labelList& eFaces = edgeFaces_[eIndex];
+
+        // Reset minQuality
+        minQuality = GREAT;
+
+        // Need to build alternate addressing / point-list
+        // for swaps across processors.
+        DynamicList<point> parPts(10);
+        DynamicList<label> parVtx(10);
+
+        bool closed = true;
+        label nPoints = 0, nProcs = 0;
+        label otherPoint = -1, nextPoint = -1;
+
+        // Define a line for this edge
+        linePointRef lpr
+        (
+            points_[checkEdge.start()],
+            points_[checkEdge.end()]
+        );
+
+        // Define tangent-to-edge / edge-centre
+        vector te = -lpr.vec(), xe = lpr.centre();
+
+        // Normalize tangent
+        te /= mag(te) + VSMALL;
+
+        // Fill-in vertices for this processor
+        forAll(eFaces, faceI)
+        {
+            label fPatch = whichPatch(eFaces[faceI]);
+            label neiProc = getNeighbourProcessor(fPatch);
+
+            if (neiProc > -1 && neiProc < Pstream::myProcNo())
+            {
+                // This edge should not be here
+                Pout<< " Edge: " << eIndex
+                    << " is talking to processor: " << neiProc
+                    << abort(FatalError);
+            }
+
+            // This face is either internal or on a physical boundary
+            const face& checkFace = faces_[eFaces[faceI]];
+
+            // Find the isolated point
+            meshOps::findIsolatedPoint
+            (
+                checkFace,
+                checkEdge,
+                otherPoint,
+                nextPoint
+            );
+
+            // Insert point and index
+            parPts.append(points_[otherPoint]);
+            parVtx.append(nPoints);
+
+            // Physical patch: Is this an appropriate start face?
+            //  - If yes, swap with first index
+            if (fPatch > -1 && neiProc == -1)
+            {
+                closed = false;
+
+                if (nextPoint == checkEdge[0])
+                {
+                    Foam::Swap(parPts[0], parPts[nPoints]);
+                }
+            }
+
+            // Increment point index
+            nPoints++;
+        }
+
+        // Now look through processors, and add their points
+        forAll(procIndices_, pI)
+        {
+            label proc = procIndices_[pI];
+
+            // Fetch reference to subMesh
+            const coupleMap& cMap = recvMeshes_[pI].map();
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            label sI = -1, sP = -1;
+
+            if ((sI = cMap.findSlave(coupleMap::EDGE, eIndex)) == -1)
+            {
+                continue;
+            }
+
+            // If this is a new edge, bail out for now.
+            // This will be handled at the next time-step.
+            if (sI >= mesh.nOldEdges_)
+            {
+                return false;
+            }
+
+            const edge& slaveEdge = mesh.edges_[sI];
+            const labelList& seFaces = mesh.edgeFaces_[sI];
+
+            // Determine the point index that corresponds to checkEdge[0]
+            edge cE
+            (
+                cMap.findMaster(coupleMap::POINT, slaveEdge[0]),
+                cMap.findMaster(coupleMap::POINT, slaveEdge[1])
+            );
+
+            if (cE[0] == checkEdge[0])
+            {
+                sP = slaveEdge[0];
+            }
+            else
+            if (cE[1] == checkEdge[0])
+            {
+                sP = slaveEdge[1];
+            }
+            else
+            {
+                label meP = whichEdgePatch(eIndex);
+                word mN(meP < 0 ? "Internal" : boundaryMesh()[meP].name());
+
+                label seP = mesh.whichEdgePatch(sI);
+                word sN(seP < 0 ? "Internal" : mesh.boundaryMesh()[seP].name());
+
+                Pout<< " Can't find master point: " << checkEdge[0] << nl
+                    << " on master: " << eIndex << "::" << checkEdge
+                    << " Patch: " << mN << nl
+                    << " with slave: " << sI << "::" << slaveEdge
+                    << " Patch: " << sN << nl
+                    << " cE: " << cE << " on proc: " << proc << nl
+                    << abort(FatalError);
+            }
+
+            forAll(seFaces, faceI)
+            {
+                label slavePatch = mesh.whichPatch(seFaces[faceI]);
+
+                // If this is talking to a lower-ranked processor,
+                // skip the insertion step.
+                label neiProc = mesh.getNeighbourProcessor(slavePatch);
+
+                if (neiProc > -1 && neiProc < proc)
+                {
+                    continue;
+                }
+
+                // This face is either internal or on a physical boundary
+                const face& slaveFace = mesh.faces_[seFaces[faceI]];
+
+                // Find the isolated point
+                meshOps::findIsolatedPoint
+                (
+                    slaveFace,
+                    slaveEdge,
+                    otherPoint,
+                    nextPoint
+                );
+
+                // Insert point and index
+                parPts.append(mesh.points_[otherPoint]);
+                parVtx.append(nPoints);
+
+                // Physical patch: Is this an appropriate start face?
+                //  - If yes, swap with first index
+                if (slavePatch > -1 && neiProc == -1)
+                {
+                    closed = false;
+
+                    if (nextPoint == sP)
+                    {
+                        Foam::Swap(parPts[0], parPts[nPoints]);
+                    }
+                }
+
+                // Increment point index
+                nPoints++;
+            }
+
+            nProcs++;
+        }
+
+        // Sort points / indices in counter-clockwise order
+        SortableList<scalar> angles(nPoints, 0.0);
+
+        // Fetch 2 * pi
+        scalar twoPi = mathematicalConstant::twoPi;
+
+        // Define a base direction
+        // from the start point
+        vector dir = (parPts[0] - xe);
+        dir -= ((dir & te) * te);
+        dir /= mag(dir) + VSMALL;
+
+        // Local coordinate system
+        coordinateSystem cs("cs", xe, te, dir);
+
+        for (label i = 1; i < nPoints; i++)
+        {
+            // Convert to local csys and determine angle
+            vector local = cs.localPosition(parPts[i]);
+            scalar angle = atan2(local.y(), local.x());
+
+            // Account for 3rd and 4th quadrants
+            angles[i] = (angle < 0.0 ? angle + twoPi : angle);
+        }
+
+        // Sort by angle
+        angles.sort();
+
+        // Reorder points and transfer
+        List<point> sortedParPts(nPoints);
+
+        const labelList& indices = angles.indices();
+
+        forAll(sortedParPts, pointI)
+        {
+            sortedParPts[pointI] = parPts[indices[pointI]];
+        }
+
+        parPts.transfer(sortedParPts);
+
+        // Fill the last two points for the edge
+        edge parEdge(-1, -1);
+
+        parPts.append(lpr.start());
+        parEdge[0] = nPoints++;
+
+        parPts.append(lpr.end());
+        parEdge[1] = nPoints++;
+
+        // Compute minQuality with this loop
+        minQuality = computeMinQuality(parEdge, parVtx, parPts, closed);
+
+        if (debug > 4 || minQuality < 0.0)
+        {
+            // Write out edge connectivity
+            writeEdgeConnectivity(eIndex);
+
+            meshOps::writeVTK
+            (
+                (*this),
+                "parPts_" + Foam::name(eIndex),
+                parPts.size(),
+                parPts.size(),
+                parPts.size(),
+                pointField(parPts)
+            );
+
+            if (minQuality < 0.0)
+            {
+                Pout<< " * * * Error in fillTables * * * " << nl
+                    << " Edge: " << eIndex << " :: " << checkEdge << nl
+                    << " minQuality: " << minQuality << nl
+                    << " Closed: " << Switch::asText(closed) << nl
+                    << abort(FatalError);
+            }
+        }
+
+        // Fill in the size
+        m[0] = parVtx.size();
+
+        // Check if a table-resize is necessary
+        if (m[0] > maxTetsPerEdge_)
+        {
+            if (allowTableResize_)
+            {
+                // Resize the tables to account for
+                // more tets per edge
+                label& mtpe = const_cast<label&>(maxTetsPerEdge_);
+
+                mtpe = m[0];
+
+                // Clear tables for this index.
+                Q[0].clear();
+                K[0].clear();
+                triangulations[0].clear();
+
+                // Resize for this index.
+                initTables(m, Q, K, triangulations);
+            }
+            else
+            {
+                // Can't resize. Bail out.
+                return false;
+            }
+        }
+
+        // Fill dynamic programming tables
+        fillTables
+        (
+            parEdge,
+            minQuality,
+            m[0],
+            parVtx,
+            parPts,
+            Q[0],
+            K[0],
+            triangulations[0]
+        );
+
+        success = true;
+    }
+
+    return success;
+}
+
+
+// Additional mapping contributions for coupled entities
+void dynamicTopoFvMesh::computeCoupledWeights
+(
+    const label index,
+    const label dimension,
+    labelList& parents,
+    scalarField& weights,
+    vectorField& centres,
+    bool output
+)
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    // Fetch offsets from mapper
+    const labelList& cStarts = mapper_->cellStarts();
+    const labelListList& pSizes = mapper_->patchSizes();
+
+    if (dimension == 2)
+    {
+        DynamicList<label> faceParents(10);
+
+        label patchIndex = whichPatch(index);
+
+        forAll(procIndices_, pI)
+        {
+            // Ensure that the patch is physical
+            if (patchIndex < 0 || patchIndex >= pSizes[pI].size())
+            {
+                Pout<< " Face: " << index
+                    << " Patch: " << patchIndex
+                    << " does not belong to a physical patch." << nl
+                    << " nPhysicalPatches: " << pSizes[pI].size()
+                    << abort(FatalError);
+            }
+
+            // Fetch reference to subMesh
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            // Prepare lists
+            labelList coupleObjects;
+            scalarField coupleWeights;
+            vectorField coupleCentres;
+
+            // Convex-set algorithm for faces
+            faceSetAlgorithm faceAlgorithm
+            (
+                mesh,
+                oldPoints_,
+                edges_,
+                faces_,
+                cells_,
+                owner_,
+                neighbour_
+            );
+
+            // Initialize the bounding box
+            faceAlgorithm.computeNormFactor(index);
+
+            // Loop through all subMesh faces, and check for bounds
+            const polyBoundaryMesh& boundary = mesh.boundaryMesh();
+
+            label pSize = boundary[patchIndex].size();
+            label pStart = boundary[patchIndex].start();
+
+            for (label faceI = pStart; faceI < (pStart + pSize); faceI++)
+            {
+                if (faceAlgorithm.contains(faceI))
+                {
+                    faceParents.append(faceI);
+                }
+            }
+
+            // Obtain weighting factors for this face.
+            faceAlgorithm.computeWeights
+            (
+                index,
+                pStart,
+                faceParents,
+                boundary[patchIndex].faceFaces(),
+                coupleObjects,
+                coupleWeights,
+                coupleCentres,
+                output
+            );
+
+            // Add contributions with offsets
+            if (coupleObjects.size())
+            {
+                // Fetch patch size on master
+                label patchSize = boundaryMesh()[patchIndex].size();
+
+                // Resize lists
+                label oldSize = parents.size();
+
+                parents.setSize(oldSize + coupleObjects.size());
+                weights.setSize(oldSize + coupleObjects.size());
+                centres.setSize(oldSize + coupleObjects.size());
+
+                forAll(coupleObjects, indexI)
+                {
+                    parents[indexI + oldSize] =
+                    (
+                        patchSize + coupleObjects[indexI]
+                    );
+
+                    weights[indexI + oldSize] = coupleWeights[indexI];
+                    centres[indexI + oldSize] = coupleCentres[indexI];
+                }
+            }
+
+            // Clear list
+            faceParents.clear();
+        }
+    }
+    else
+    if (dimension == 3)
+    {
+        DynamicList<label> cellParents(10);
+
+        forAll(procIndices_, pI)
+        {
+            // Fetch reference to subMesh
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            // Prepare lists
+            labelList coupleObjects;
+            scalarField coupleWeights;
+            vectorField coupleCentres;
+
+            // Convex-set algorithm for cells
+            cellSetAlgorithm cellAlgorithm
+            (
+                mesh,
+                oldPoints_,
+                edges_,
+                faces_,
+                cells_,
+                owner_,
+                neighbour_
+            );
+
+            // Initialize the bounding box
+            cellAlgorithm.computeNormFactor(index);
+
+            // Loop through all subMesh cells, and check for bounds
+            const cellList& meshCells = mesh.cells();
+
+            forAll(meshCells, cellI)
+            {
+                if (cellAlgorithm.contains(cellI))
+                {
+                    cellParents.append(cellI);
+                }
+            }
+
+            // Obtain weighting factors for this cell.
+            cellAlgorithm.computeWeights
+            (
+                index,
+                0,
+                cellParents,
+                mesh.polyMesh::cellCells(),
+                coupleObjects,
+                coupleWeights,
+                coupleCentres,
+                output
+            );
+
+            // Add contributions with offsets
+            if (coupleObjects.size())
+            {
+                label cellStart = cStarts[pI];
+
+                // Resize lists
+                label oldSize = parents.size();
+
+                parents.setSize(oldSize + coupleObjects.size());
+                weights.setSize(oldSize + coupleObjects.size());
+                centres.setSize(oldSize + coupleObjects.size());
+
+                forAll(coupleObjects, indexI)
+                {
+                    parents[indexI + oldSize] =
+                    (
+                        cellStart + coupleObjects[indexI]
+                    );
+
+                    weights[indexI + oldSize] = coupleWeights[indexI];
+                    centres[indexI + oldSize] = coupleCentres[indexI];
+                }
+            }
+
+            // Clear list
+            cellParents.clear();
+        }
+    }
+    else
+    {
+        FatalErrorIn("scalar dynamicTopoFvMesh::computeCoupledWeights()")
+            << " Incorrect dimension: " << dimension << nl
+            << abort(FatalError);
+    }
+}
+
+
+// Fetch length-scale info for processor entities
+scalar dynamicTopoFvMesh::processorLengthScale(const label index) const
+{
+    scalar procScale = 0.0;
+
+    if (twoDMesh_)
+    {
+        // First check the master processor
+        procScale += lengthScale_[owner_[index]];
+
+        // Next, check the slave processor
+        bool foundSlave = false;
+
+        forAll(procIndices_, pI)
+        {
+            // Fetch non-const reference to subMeshes
+            const label faceEnum = coupleMap::FACE;
+            const coupleMap& cMap = recvMeshes_[pI].map();
+            const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+            label sIndex = -1;
+
+            if ((sIndex = cMap.findSlave(faceEnum, index)) > -1)
+            {
+                procScale += mesh.lengthScale_[mesh.owner_[sIndex]];
+
+                foundSlave = true;
+                break;
+            }
+        }
+
+        // Should have found at least one slave
+        if (!foundSlave)
+        {
+            FatalErrorIn
+            (
+                "scalar dynamicTopoFvMesh::processorLengthScale"
+                "(const label index) const"
+            )
+                << "Processor lengthScale lookup failed: " << nl
+                << " Master face: " << index
+                << " :: " << faces_[index] << nl
+                << abort(FatalError);
+        }
+
+        // Average the scale
+        procScale *= 0.5;
+    }
+    else
+    {
+        // Check if this is a 'pure' processor edge
+        bool pure = processorCoupledEntity(index, false, true, true);
+
+        const label edgeEnum = coupleMap::EDGE;
+        const labelList& eFaces = edgeFaces_[index];
+
+        bool foundSlave = false;
+
+        if (pure)
+        {
+            // First check the master processor
+            label nC = 0;
+
+            forAll(eFaces, faceI)
+            {
+                label own = owner_[eFaces[faceI]];
+                label nei = neighbour_[eFaces[faceI]];
+
+                procScale += lengthScale_[own];
+                nC++;
+
+                if (nei > -1)
+                {
+                    procScale += lengthScale_[nei];
+                    nC++;
+                }
+            }
+
+            // Next check slaves
+            forAll(procIndices_, pI)
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+                label sIndex = -1;
+
+                if ((sIndex = cMap.findSlave(edgeEnum, index)) > -1)
+                {
+                    // Fetch connectivity from patchSubMesh
+                    const labelList& peFaces = mesh.edgeFaces_[sIndex];
+
+                    foundSlave = true;
+
+                    forAll(peFaces, faceI)
+                    {
+                        label own = mesh.owner_[peFaces[faceI]];
+                        label nei = mesh.neighbour_[peFaces[faceI]];
+
+                        procScale += mesh.lengthScale_[own];
+                        nC++;
+
+                        if (nei > -1)
+                        {
+                            procScale += mesh.lengthScale_[nei];
+                            nC++;
+                        }
+                    }
+                }
+            }
+
+            // Average the final scale
+            procScale /= nC;
+        }
+        else
+        {
+            // Processor is adjacent to physical patch types.
+            // Search for boundary faces, and average their scale
+
+            // First check the master processor
+            label nBoundary = 0;
+
+            forAll(eFaces, faceI)
+            {
+                label facePatch = whichPatch(eFaces[faceI]);
+
+                // Skip internal faces
+                if (facePatch == -1)
+                {
+                    continue;
+                }
+
+                // Skip processor patches
+                if (getNeighbourProcessor(facePatch) > -1)
+                {
+                    continue;
+                }
+
+                // If this is a floating face, pick the owner length-scale
+                if (lengthEstimator().isFreePatch(facePatch))
+                {
+                    procScale += lengthScale_[owner_[eFaces[faceI]]];
+                }
+                else
+                {
+                    // Fetch fixed length-scale
+                    procScale +=
+                    (
+                        lengthEstimator().fixedLengthScale
+                        (
+                            eFaces[faceI],
+                            facePatch
+                        )
+                    );
+                }
+
+                nBoundary++;
+            }
+
+            forAll(procIndices_, pI)
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+                label sIndex = -1;
+
+                if ((sIndex = cMap.findSlave(edgeEnum, index)) > -1)
+                {
+                    // Fetch connectivity from patchSubMesh
+                    const labelList& peFaces = mesh.edgeFaces_[sIndex];
+
+                    foundSlave = true;
+
+                    forAll(peFaces, faceI)
+                    {
+                        label facePatch = mesh.whichPatch(peFaces[faceI]);
+
+                        // Skip internal faces
+                        if (facePatch == -1)
+                        {
+                            continue;
+                        }
+
+                        // Skip processor patches
+                        if (mesh.getNeighbourProcessor(facePatch) > -1)
+                        {
+                            continue;
+                        }
+
+                        // If this is a floating face,
+                        // pick the owner length-scale
+                        if (lengthEstimator().isFreePatch(facePatch))
+                        {
+                            procScale +=
+                            (
+                                mesh.lengthScale_[mesh.owner_[peFaces[faceI]]]
+                            );
+                        }
+                        else
+                        {
+                            // Fetch fixed length-scale
+                            procScale +=
+                            (
+                                lengthEstimator().fixedLengthScale
+                                (
+                                    peFaces[faceI],
+                                    facePatch
+                                )
+                            );
+                        }
+
+                        nBoundary++;
+                    }
+                }
+            }
+
+            if (nBoundary != 2)
+            {
+                // Write out for post-processing
+                writeEdgeConnectivity(index);
+
+                FatalErrorIn
+                (
+                    "scalar dynamicTopoFvMesh::processorLengthScale"
+                    "(const label index) const"
+                )
+                    << " Expected two physical boundary patches: " << nl
+                    << " nBoundary: " << nBoundary
+                    << " Master edge: " << index
+                    << " :: " << edges_[index]
+                    << " Patch: "
+                    << boundaryMesh()[whichEdgePatch(index)].name() << nl
+                    << abort(FatalError);
+            }
+
+            procScale *= 0.5;
+        }
+
+        // Should have found at least one slave
+        if (!foundSlave)
+        {
+            FatalErrorIn
+            (
+                "scalar dynamicTopoFvMesh::processorLengthScale"
+                "(const label index) const"
+            )
+                << "Processor lengthScale lookup failed: " << nl
+                << " Master edge: " << index
+                << " :: " << edges_[index] << nl
+                << abort(FatalError);
+        }
+    }
+
+    return procScale;
+}
+
+
+// Method to determine whether the master face is locally coupled
+bool dynamicTopoFvMesh::locallyCoupledEntity
+(
+    const label index,
+    bool checkSlaves,
+    bool checkProcs,
+    bool checkFace
+) const
+{
+    // Bail out if no patchCoupling is present
+    if (patchCoupling_.empty())
+    {
+        return false;
+    }
+
+    if (twoDMesh_ || checkFace)
+    {
+        label patch = whichPatch(index);
+
+        if (patch == -1)
+        {
+            return false;
+        }
+
+        // Processor checks receive priority.
+        if (checkProcs)
+        {
+            if (getNeighbourProcessor(patch) > -1)
+            {
+                return false;
+            }
+        }
+
+        // Check coupled master patches.
+        if (patchCoupling_(patch))
+        {
+            return true;
+        }
+        else
+        if (checkSlaves)
+        {
+            // Check on slave patches as well.
+            forAll(patchCoupling_, pI)
+            {
+                if (patchCoupling_(pI))
+                {
+                    const coupleMap& cMap = patchCoupling_[pI].map();
+
+                    if (cMap.slaveIndex() == patch)
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        const labelList& eFaces = edgeFaces_[index];
+
+        // Search for boundary faces, and determine boundary type.
+        forAll(eFaces, faceI)
+        {
+            if (neighbour_[eFaces[faceI]] == -1)
+            {
+                label patch = whichPatch(eFaces[faceI]);
+
+                // Processor checks receive priority.
+                if (checkProcs)
+                {
+                    if (getNeighbourProcessor(patch) > -1)
+                    {
+                        return false;
+                    }
+                }
+
+                // Check coupled master patches.
+                if (patchCoupling_(patch))
+                {
+                    return true;
+                }
+
+                if (checkSlaves)
+                {
+                    // Check on slave patches as well.
+                    forAll(patchCoupling_, pI)
+                    {
+                        if (patchCoupling_(pI))
+                        {
+                            const coupleMap& cMap =
+                            (
+                                patchCoupling_[pI].map()
+                            );
+
+                            if (cMap.slaveIndex() == patch)
+                            {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Could not find any faces on locally coupled patches.
+    return false;
+}
+
+
+// Method to determine the locally coupled patch index
+label dynamicTopoFvMesh::locallyCoupledEdgePatch(const label eIndex) const
+{
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    // Search for boundary faces, and determine boundary type.
+    forAll(eFaces, faceI)
+    {
+        if (neighbour_[eFaces[faceI]] == -1)
+        {
+            label patch = whichPatch(eFaces[faceI]);
+
+            // Check coupled master patches.
+            if (patchCoupling_(patch))
+            {
+                return patch;
+            }
+
+            // Check on slave patches as well.
+            forAll(patchCoupling_, pI)
+            {
+                if (patchCoupling_(pI))
+                {
+                    const coupleMap& cMap = patchCoupling_[pI].map();
+
+                    if (cMap.slaveIndex() == patch)
+                    {
+                        return patch;
+                    }
+                }
+            }
+        }
+    }
+
+    // Could not find any faces on locally coupled patches.
+    FatalErrorIn
+    (
+        "label dynamicTopoFvMesh::locallyCoupledEdgePatch"
+        "(const label cIndex) const"
+    )
+        << "Edge: " << eIndex << ":: " << edges_[eIndex]
+        << " does not lie on any coupled patches."
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+// Method to determine if the entity is on a processor boundary
+//  - Also provides an additional check for 'pure' processor edges
+//    i.e., edges that do not abut a physical patch. This is necessary
+//    while deciding on collapse cases towards bounding curves.
+bool dynamicTopoFvMesh::processorCoupledEntity
+(
+    const label index,
+    bool checkFace,
+    bool checkEdge,
+    bool checkPure,
+    FixedList<label, 2>* patchLabels,
+    FixedList<vector, 2>* patchNormals
+) const
+{
+    // Skip check for serial runs
+    if (!Pstream::parRun())
+    {
+        return false;
+    }
+
+    label patch = -2;
+
+    if ((twoDMesh_ || checkFace) && !checkEdge)
+    {
+        patch = whichPatch(index);
+
+        if (patch == -1)
+        {
+            return false;
+        }
+
+        if (getNeighbourProcessor(patch) > -1)
+        {
+            return true;
+        }
+    }
+    else
+    {
+        const labelList& eFaces = edgeFaces_[index];
+
+        label nPhysical = 0, nProcessor = 0;
+
+        // Search for boundary faces, and determine boundary type.
+        forAll(eFaces, faceI)
+        {
+            label patch = whichPatch(eFaces[faceI]);
+
+            if (patch == -1)
+            {
+                continue;
+            }
+
+            if (getNeighbourProcessor(patch) > -1)
+            {
+                // Increment the processor patch count
+                nProcessor++;
+
+                if (!checkPure)
+                {
+                    // We don't have to validate if this
+                    // is a 'pure' processor edge, so bail out.
+                    return true;
+                }
+            }
+            else
+            {
+                // Physical patch.
+                if (patchLabels)
+                {
+                    (*patchLabels)[nPhysical] = patch;
+                }
+
+                if (patchNormals)
+                {
+                    (*patchNormals)[nPhysical] =
+                    (
+                        faces_[eFaces[faceI]].normal(points_)
+                    );
+                }
+
+                nPhysical++;
+            }
+        }
+
+        if (patchLabels && patchNormals)
+        {
+            // Check other coupled-edges as well
+            forAll(procIndices_, pI)
+            {
+                // Fetch reference to subMesh
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+                label sI = -1;
+
+                if ((sI = cMap.findSlave(coupleMap::EDGE, index)) == -1)
+                {
+                    continue;
+                }
+
+                const labelList& seFaces = mesh.edgeFaces_[sI];
+
+                forAll(seFaces, faceI)
+                {
+                    label sPatch = mesh.whichPatch(seFaces[faceI]);
+                    label neiProc = mesh.getNeighbourProcessor(sPatch);
+
+                    // Skip internal / processor faces
+                    if (sPatch == -1 || neiProc > -1)
+                    {
+                        continue;
+                    }
+
+                    const face& sFace = mesh.faces_[seFaces[faceI]];
+
+                    // Fill patch / normal info
+                    (*patchLabels)[nPhysical] = sPatch;
+                    (*patchNormals)[nPhysical] = sFace.normal(mesh.points_);
+
+                    nPhysical++;
+                }
+            }
+        }
+
+        // Purity check
+        if (checkPure)
+        {
+            if (nProcessor && !nPhysical)
+            {
+                return true;
+            }
+        }
+    }
+
+    // Could not find any faces on processor patches.
+    return false;
+}
+
+
+// Build a list of entities that need to be avoided
+// by regular topo-changes.
+void dynamicTopoFvMesh::buildEntitiesToAvoid
+(
+    labelHashSet& entities,
+    bool checkSubMesh
+)
+{
+    entities.clear();
+
+    // Build a set of entities to avoid during regular modifications,
+    // and build a master stack for coupled modifications.
+
+    // Determine locally coupled slave patches.
+    labelHashSet localMasterPatches, localSlavePatches;
+
+    forAll(patchCoupling_, patchI)
+    {
+        if (patchCoupling_(patchI))
+        {
+            const coupleMap& cMap = patchCoupling_[patchI].map();
+
+            localMasterPatches.insert(cMap.masterIndex());
+            localSlavePatches.insert(cMap.slaveIndex());
+        }
+    }
+
+    // Loop through boundary faces and check whether
+    // they belong to master/slave coupled patches.
+    for (label faceI = nOldInternalFaces_; faceI < faces_.size(); faceI++)
+    {
+        // Add only valid faces
+        if (faces_[faceI].empty())
+        {
+            continue;
+        }
+
+        label pIndex = whichPatch(faceI);
+
+        if (pIndex == -1)
+        {
+            continue;
+        }
+
+        // Check if this is a coupled face.
+        if
+        (
+            localMasterPatches.found(pIndex) ||
+            localSlavePatches.found(pIndex) ||
+            getNeighbourProcessor(pIndex) > -1
+        )
+        {
+            if (twoDMesh_)
+            {
+                // Avoid this face during regular modification.
+                if (!entities.found(faceI))
+                {
+                    entities.insert(faceI);
+                }
+            }
+            else
+            {
+                const labelList& fEdges = faceEdges_[faceI];
+
+                forAll(fEdges, edgeI)
+                {
+                    // Avoid this edge during regular modification.
+                    if (!entities.found(fEdges[edgeI]))
+                    {
+                        entities.insert(fEdges[edgeI]);
+                    }
+                }
+            }
+        }
+    }
+
+    // Loop through entities contained in patchSubMeshes, if requested
+    if (checkSubMesh)
+    {
+        forAll(procIndices_, pI)
+        {
+            const coupleMap& cMap = sendMeshes_[pI].map();
+            const Map<label> rEdgeMap = cMap.reverseEntityMap(coupleMap::EDGE);
+
+            if (cMap.slaveIndex() == Pstream::myProcNo())
+            {
+                forAllConstIter(Map<label>, rEdgeMap, eIter)
+                {
+                    if (twoDMesh_)
+                    {
+                        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+                        forAll(eFaces, faceI)
+                        {
+                            if (faces_[eFaces[faceI]].size() == 4)
+                            {
+                                if (!entities.found(eFaces[faceI]))
+                                {
+                                    entities.insert(eFaces[faceI]);
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        const edge& check = edges_[eIter.key()];
+                        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+                        // Skip deleted edges
+                        if (eFaces.size())
+                        {
+                            forAll(check, pI)
+                            {
+                                const labelList& pE = pointEdges_[check[pI]];
+
+                                forAll(pE, edgeI)
+                                {
+                                    if (!entities.found(pE[edgeI]))
+                                    {
+                                        entities.insert(pE[edgeI]);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (debug > 3)
+    {
+        Pout<< nl << "nEntitiesToAvoid: " << entities.size() << endl;
+
+        if (debug > 4)
+        {
+            // Write out entities
+            label elemType = twoDMesh_ ? 2 : 1;
+
+            writeVTK
+            (
+                "entitiesToAvoid_"
+              + Foam::name(Pstream::myProcNo()),
+                entities.toc(),
+                elemType
+            );
+        }
+    }
+}
+
+
+// Check whether the specified edge is a coupled master edge.
+bool dynamicTopoFvMesh::isCoupledMaster
+(
+    const label eIndex
+) const
+{
+    if (!coupledModification_)
+    {
+        return true;
+    }
+
+    return locallyCoupledEntity(eIndex);
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
index 48996badd..fa0061b03 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
@@ -199,272 +199,6 @@ inline label dynamicTopoFvMesh::getTriBoundaryEdge
 }
 
 
-// Return length-scale at an face-location in the mesh [2D]
-inline scalar dynamicTopoFvMesh::faceLengthScale
-(
-    const label fIndex
-) const
-{
-    // Reset the scale first
-    scalar scale = 0.0;
-
-    label facePatch = whichPatch(fIndex);
-
-    // Determine whether the face is internal
-    if (facePatch < 0)
-    {
-#       ifdef FULLDEBUG
-        // Check whether neighbour is valid
-        if (neighbour_[fIndex] == -1)
-        {
-            FatalErrorIn
-            (
-                "inline scalar dynamicTopoFvMesh::faceLengthScale"
-                "(const label fIndex) const"
-            )
-                << nl << "Face: " << fIndex
-                << ": " << faces_[fIndex]
-                << " is not internal."
-                << abort(FatalError);
-        }
-#       endif
-
-        scale =
-        (
-            0.5 *
-            (
-                lengthScale_[owner_[fIndex]]
-              + lengthScale_[neighbour_[fIndex]]
-            )
-        );
-    }
-    else
-    {
-        // Fetch the fixed-length scale
-        scale = lengthEstimator().fixedLengthScale(fIndex, facePatch);
-
-        // If this is a floating face, pick the owner length-scale
-        if (lengthEstimator().isFreePatch(facePatch))
-        {
-            scale = lengthScale_[owner_[fIndex]];
-        }
-
-        // If proximity-based refinement is requested,
-        // test the proximity to the nearest non-neighbour.
-        if (lengthEstimator().isProximityPatch(facePatch))
-        {
-            label proximityFace = -1;
-
-            // Perform a proximity-check.
-            scalar distance = testProximity(fIndex, proximityFace);
-
-            if (debug > 3 && self() == 0)
-            {
-                if
-                (
-                    (proximityFace > -1) &&
-                    ((distance / 5.0) < scale)
-                )
-                {
-                    Info << " Closest opposing face detected for face: " << nl
-                         << '\t' << fIndex
-                         << " :: " << faces_[fIndex]
-                         << " was face:\n"
-                         << '\t' << proximityFace
-                         << " :: " << polyMesh::faces()[proximityFace] << nl
-                         << " with distance: " << distance
-                         << endl;
-                }
-            }
-
-            scale =
-            (
-                Foam::min
-                (
-                    scale,
-                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
-                )
-            );
-        }
-
-        // Limit scales if necessary
-        lengthEstimator().limitScale(scale);
-    }
-
-    return scale;
-}
-
-
-// Compute length-scale at an edge-location in the mesh [3D]
-inline scalar dynamicTopoFvMesh::edgeLengthScale
-(
-    const label eIndex
-) const
-{
-    // Reset the scale first
-    scalar scale = 0.0;
-
-    const labelList& eFaces = edgeFaces_[eIndex];
-
-    label edgePatch = whichEdgePatch(eIndex);
-
-    // Determine whether the edge is internal
-    if (edgePatch < 0)
-    {
-        forAll(eFaces, faceI)
-        {
-#           ifdef FULLDEBUG
-            // Check whether neighbour is valid
-            if (neighbour_[eFaces[faceI]] == -1)
-            {
-                FatalErrorIn
-                (
-                    "inline scalar dynamicTopoFvMesh::edgeLengthScale"
-                    "(const label eIndex) const"
-                )
-                    << nl << "Face: " << eFaces[faceI]
-                    << ": " << faces_[eFaces[faceI]]
-                    << " is not internal, while edge: "
-                    << eIndex << ": " << edges_[eIndex] << " is."
-                    << abort(FatalError);
-            }
-#           endif
-
-            scale += lengthScale_[owner_[eFaces[faceI]]];
-            scale += lengthScale_[neighbour_[eFaces[faceI]]];
-        }
-
-        scale /= (2.0*eFaces.size());
-    }
-    else
-    {
-        // Search for boundary faces, and average their scale
-        forAll(eFaces, faceI)
-        {
-            if (neighbour_[eFaces[faceI]] == -1)
-            {
-                scale +=
-                (
-                    lengthEstimator().fixedLengthScale
-                    (
-                        eFaces[faceI],
-                        edgePatch
-                    )
-                );
-            }
-        }
-
-        scale *= 0.5;
-
-        // If proximity-based refinement is requested,
-        // test the proximity to the nearest non-neighbour.
-        if (lengthEstimator().isProximityPatch(edgePatch))
-        {
-            label proximityFace = -1;
-
-            // Perform a proximity-check.
-            scalar distance = testProximity(eIndex, proximityFace);
-
-            if (debug > 3 && self() == 0)
-            {
-                if
-                (
-                    (proximityFace > -1) &&
-                    ((distance / 5.0) < scale)
-                )
-                {
-                    Info << " Closest opposing face detected for edge: " << nl
-                         << '\t' << eIndex
-                         << " :: " << edges_[eIndex]
-                         << " was face:\n"
-                         << '\t' << proximityFace
-                         << " :: " << polyMesh::faces()[proximityFace] << nl
-                         << " with distance: " << distance
-                         << endl;
-                }
-            }
-
-            scale =
-            (
-                Foam::min
-                (
-                    scale,
-                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
-                )
-            );
-        }
-
-        // If curvature-based refinement is requested,
-        // test the variation in face-normal directions.
-        if (lengthEstimator().isCurvaturePatch(edgePatch))
-        {
-            // Obtain face-normals for both faces.
-            label count = 0;
-            FixedList<vector, 2> fNorm;
-
-            forAll(eFaces, faceI)
-            {
-                if (neighbour_[eFaces[faceI]] == -1)
-                {
-                    // Obtain the normal.
-                    fNorm[count] = faces_[eFaces[faceI]].normal(points_);
-
-                    // Normalize it.
-                    fNorm[count] /= mag(fNorm[count]);
-
-                    count++;
-                }
-            }
-
-            scalar deviation = (fNorm[0] & fNorm[1]);
-            scalar refDeviation = lengthEstimator().curvatureDeviation();
-
-            if (mag(deviation) < refDeviation)
-            {
-                // Fetch the edge
-                const edge& edgeToCheck = edges_[eIndex];
-
-                // Get the edge-length.
-                scalar length =
-                (
-                    linePointRef
-                    (
-                        points_[edgeToCheck.start()],
-                        points_[edgeToCheck.end()]
-                    ).mag()
-                );
-
-                if (debug > 3 && self() == 0)
-                {
-                    Info << "Deviation: " << deviation << nl
-                         << "curvatureDeviation: " << refDeviation
-                         << ", Edge: " << eIndex << ", Length: " << length
-                         << ", Scale: " << scale << nl
-                         << " Half-length: " << (0.5*length) << nl
-                         << " MinRatio: "
-                         << (lengthEstimator().ratioMin()*scale)
-                         << endl;
-                }
-
-                scale =
-                (
-                    Foam::min
-                    (
-                        scale,
-                        ((length - SMALL)/lengthEstimator().ratioMax())
-                    )
-                );
-            }
-        }
-
-        // Limit scales if necessary
-        lengthEstimator().limitScale(scale);
-    }
-
-    return scale;
-}
-
-
 // Check for edge bisection
 inline bool dynamicTopoFvMesh::checkBisection
 (
@@ -475,6 +209,12 @@ inline bool dynamicTopoFvMesh::checkBisection
 
     if (twoDMesh_)
     {
+        // If this entity was deleted, skip it.
+        if (faces_[index].empty())
+        {
+            return false;
+        }
+
         // Fetch the edge
         const edge& edgeToCheck = edges_[getTriBoundaryEdge(index)];
 
@@ -493,6 +233,12 @@ inline bool dynamicTopoFvMesh::checkBisection
     }
     else
     {
+        // If this entity was deleted, skip it.
+        if (edgeFaces_[index].empty())
+        {
+            return false;
+        }
+
         // Fetch the edge
         const edge& edgeToCheck = edges_[index];
 
@@ -531,6 +277,12 @@ inline bool dynamicTopoFvMesh::checkCollapse
 
     if (twoDMesh_)
     {
+        // If this entity was deleted, skip it.
+        if (faces_[index].empty())
+        {
+            return false;
+        }
+
         // Fetch the edge
         const edge& edgeToCheck = edges_[getTriBoundaryEdge(index)];
 
@@ -549,6 +301,12 @@ inline bool dynamicTopoFvMesh::checkCollapse
     }
     else
     {
+        // If this entity was deleted, skip it.
+        if (edgeFaces_[index].empty())
+        {
+            return false;
+        }
+
         // Fetch the edge
         const edge& edgeToCheck = edges_[index];
 
@@ -637,6 +395,15 @@ inline void dynamicTopoFvMesh::initStacks
     {
         forAll(faces_, faceI)
         {
+            // For coupled meshes, avoid certain faces.
+            if (patchCoupling_.size() || procIndices_.size())
+            {
+                if (entities.found(faceI))
+                {
+                    continue;
+                }
+            }
+
             if (faces_[faceI].size() == 4)
             {
                 stack(tID[tIndex]).insert(faceI);
@@ -649,6 +416,15 @@ inline void dynamicTopoFvMesh::initStacks
     {
         forAll(edges_, edgeI)
         {
+            // For coupled meshes, avoid certain edges.
+            if (patchCoupling_.size() || procIndices_.size())
+            {
+                if (entities.found(edgeI))
+                {
+                    continue;
+                }
+            }
+
             if (edgeFaces_[edgeI].size())
             {
                 stack(tID[tIndex]).insert(edgeI);
@@ -657,6 +433,32 @@ inline void dynamicTopoFvMesh::initStacks
             }
         }
     }
+
+    if (debug > 3 && Pstream::parRun())
+    {
+        Pout<< nl << "Stack size: " << stack(0).size() << endl;
+
+        if (debug > 4)
+        {
+            // Write out stack entities
+            labelList stackElements(stack(0).size(), -1);
+
+            forAll(stackElements, elemI)
+            {
+                stackElements[elemI] = stack(0)[elemI];
+            }
+
+            label elemType = twoDMesh_ ? 2 : 1;
+
+            writeVTK
+            (
+                "Stack_"
+              + Foam::name(Pstream::myProcNo()),
+                stackElements,
+                elemType
+            );
+        }
+    }
 }
 
 
@@ -686,9 +488,11 @@ inline label dynamicTopoFvMesh::whichPatch
 
     // If not in any of the above, it's possible that the face was added
     // at the end of the list. Check addedFacePatches_ for the patch info
-    if (addedFacePatches_.found(index))
+    Map<label>::const_iterator it = addedFacePatches_.find(index);
+
+    if (it != addedFacePatches_.end())
     {
-        return addedFacePatches_[index];
+        return it();
     }
     else
     {
@@ -737,9 +541,11 @@ inline label dynamicTopoFvMesh::whichEdgePatch
 
     // If not in any of the above, it's possible that the edge was added
     // at the end of the list. Check addedEdgePatches_ for the patch info
-    if (addedEdgePatches_.found(index))
+    Map<label>::const_iterator it = addedEdgePatches_.find(index);
+
+    if (it != addedEdgePatches_.end())
     {
-        return addedEdgePatches_[index];
+        return it();
     }
     else
     {
@@ -799,13 +605,15 @@ inline void dynamicTopoFvMesh::setFlip(const label fIndex)
 {
     if (fIndex < nOldFaces_)
     {
-        if (flipFaces_.found(fIndex))
+        labelHashSet::iterator it = flipFaces_.find(fIndex);
+
+        if (it == flipFaces_.end())
         {
-            flipFaces_.erase(fIndex);
+            flipFaces_.insert(fIndex);
         }
         else
         {
-            flipFaces_.insert(fIndex);
+            flipFaces_.erase(it);
         }
     }
 }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
index 73b6318b8..32fbd34a3 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
@@ -37,14 +37,21 @@ Author
 
 #include "dynamicTopoFvMesh.H"
 
+#include "Time.H"
 #include "meshOps.H"
 #include "IOmanip.H"
 #include "triFace.H"
 #include "objectMap.H"
+#include "faceSetAlgorithm.H"
+#include "cellSetAlgorithm.H"
 
 namespace Foam
 {
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTemplateTypeNameAndDebugWithName(IOList<objectMap>, "objectMapIOList", 0);
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Compute mapping weights for modified entities
@@ -52,77 +59,397 @@ void dynamicTopoFvMesh::computeMapping
 (
     const scalar matchTol,
     const bool skipMapping,
+    const bool mappingOutput,
     const label faceStart,
     const label faceSize,
     const label cellStart,
     const label cellSize
 )
 {
+    // Convex-set algorithm for cells
+    cellSetAlgorithm cellAlgorithm
+    (
+        (*this),
+        oldPoints_,
+        edges_,
+        faces_,
+        cells_,
+        owner_,
+        neighbour_
+    );
+
+    label nInconsistencies = 0;
+    scalar maxFaceError = 0.0, maxCellError = 0.0;
+    DynamicList<scalar> cellErrors(10), faceErrors(10);
+    DynamicList<objectMap> failedCells(10), failedFaces(10);
+
     // Compute cell mapping
     for (label cellI = cellStart; cellI < (cellStart + cellSize); cellI++)
     {
         label cIndex = cellsFromCells_[cellI].index();
+        labelList& masterObjects = cellsFromCells_[cellI].masterObjects();
 
         if (skipMapping)
         {
-            // Set empty mapping parameters
-            const labelList& mo = cellParents_[cIndex];
-
-            cellsFromCells_[cellI].masterObjects() = mo;
-            cellWeights_[cellI].setSize(mo.size(), (1.0/(mo.size() + VSMALL)));
-            cellCentres_[cellI].setSize(mo.size(), vector::zero);
+            // Dummy map from cell[0]
+            masterObjects = labelList(1, 0);
+            cellWeights_[cellI].setSize(1, 1.0);
+            cellCentres_[cellI].setSize(1, vector::zero);
         }
         else
         {
-            // Compute master objects for inverse-distance weighting
-            computeParents
+            // Obtain weighting factors for this cell.
+            cellAlgorithm.computeWeights
             (
                 cIndex,
+                0,
                 cellParents_[cIndex],
                 polyMesh::cellCells(),
-                polyMesh::cellCentres(),
-                3,
-                cellsFromCells_[cellI].masterObjects()
+                masterObjects,
+                cellWeights_[cellI],
+                cellCentres_[cellI]
             );
+
+            // Add contributions from subMeshes, if any.
+            computeCoupledWeights
+            (
+                cIndex,
+                cellAlgorithm.dimension(),
+                masterObjects,
+                cellWeights_[cellI],
+                cellCentres_[cellI]
+            );
+
+            // Compute error
+            scalar error = mag(1.0 - sum(cellWeights_[cellI]));
+
+            if (error > matchTol)
+            {
+                bool consistent = false;
+
+                // Check whether any edges lie on boundary patches.
+                // These cells can have relaxed weights to account
+                // for mild convexity.
+                const cell& cellToCheck = cells_[cIndex];
+
+                if (twoDMesh_)
+                {
+                    const labelList& parents = cellParents_[cIndex];
+
+                    forAll(parents, cI)
+                    {
+                        const cell& pCell = polyMesh::cells()[parents[cI]];
+
+                        forAll(pCell, fI)
+                        {
+                            const face& pFace = polyMesh::faces()[pCell[fI]];
+
+                            if (pFace.size() == 3)
+                            {
+                                continue;
+                            }
+
+                            label fP = boundaryMesh().whichPatch(pCell[fI]);
+
+                            // Disregard processor patches
+                            if (getNeighbourProcessor(fP) > -1)
+                            {
+                                continue;
+                            }
+
+                            if (fP > -1)
+                            {
+                                consistent = true;
+                                break;
+                            }
+                        }
+
+                        if (consistent)
+                        {
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    forAll(cellToCheck, fI)
+                    {
+                        const labelList& fE = faceEdges_[cellToCheck[fI]];
+
+                        forAll(fE, eI)
+                        {
+                            label eP = whichEdgePatch(fE[eI]);
+
+                            // Disregard processor patches
+                            if (getNeighbourProcessor(eP) > -1)
+                            {
+                                continue;
+                            }
+
+                            if (eP > -1)
+                            {
+                                consistent = true;
+                                break;
+                            }
+                        }
+
+                        if (consistent)
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                if (!consistent)
+                {
+                    nInconsistencies++;
+
+                    // Add to list
+                    cellErrors.append(error);
+
+                    // Accumulate error stats
+                    maxCellError = Foam::max(maxCellError, error);
+
+                    failedCells.append
+                    (
+                        objectMap
+                        (
+                            cIndex,
+                            cellParents_[cIndex]
+                        )
+                    );
+                }
+            }
         }
     }
 
+    // Convex-set algorithm for faces
+    faceSetAlgorithm faceAlgorithm
+    (
+        (*this),
+        oldPoints_,
+        edges_,
+        faces_,
+        cells_,
+        owner_,
+        neighbour_
+    );
+
     // Compute face mapping
     for (label faceI = faceStart; faceI < (faceStart + faceSize); faceI++)
     {
         label fIndex = facesFromFaces_[faceI].index();
-        label patchIndex = whichPatch(fIndex);
+        labelList& masterObjects = facesFromFaces_[faceI].masterObjects();
 
-        // Skip mapping for internal faces.
-        if (patchIndex == -1)
+        label patchIndex = whichPatch(fIndex);
+        label neiProc = getNeighbourProcessor(patchIndex);
+
+        // Skip mapping for internal / processor faces.
+        if (patchIndex == -1 || neiProc > -1)
         {
             // Set dummy masters, so that the conventional
-            // faceMapper doesn't incur a seg-fault.
-            facesFromFaces_[faceI].masterObjects() = labelList(1, 0);
+            // faceMapper doesn't crash-and-burn
+            masterObjects = labelList(1, 0);
+
             continue;
         }
 
         if (skipMapping)
         {
-            // Set empty mapping parameters
-            const labelList& mo = faceParents_[fIndex];
-
-            facesFromFaces_[faceI].masterObjects() = mo;
-            faceWeights_[faceI].setSize(mo.size(), (1.0/(mo.size() + VSMALL)));
-            faceCentres_[faceI].setSize(mo.size(), vector::zero);
+            // Dummy map from patch[0]
+            masterObjects = labelList(1, 0);
+            faceWeights_[faceI].setSize(1, 1.0);
+            faceCentres_[faceI].setSize(1, vector::zero);
         }
         else
         {
-            // Compute master objects for inverse-distance weighting
-            computeParents
+            // Obtain weighting factors for this face.
+            faceAlgorithm.computeWeights
             (
                 fIndex,
+                boundaryMesh()[patchIndex].start(),
                 faceParents_[fIndex],
                 boundaryMesh()[patchIndex].faceFaces(),
-                boundaryMesh()[patchIndex].faceCentres(),
-                2,
-                facesFromFaces_[faceI].masterObjects()
+                masterObjects,
+                faceWeights_[faceI],
+                faceCentres_[faceI]
             );
+
+            // Add contributions from subMeshes, if any.
+            computeCoupledWeights
+            (
+                fIndex,
+                faceAlgorithm.dimension(),
+                masterObjects,
+                faceWeights_[faceI],
+                faceCentres_[faceI]
+            );
+
+            // Compute error
+            scalar error = mag(1.0 - sum(faceWeights_[faceI]));
+
+            if (error > matchTol)
+            {
+                bool consistent = false;
+
+                // Check whether any edges lie on bounding curves.
+                // These faces can have relaxed weights to account
+                // for addressing into patches on the other side
+                // of the curve.
+                const labelList& fEdges = faceEdges_[fIndex];
+
+                forAll(fEdges, eI)
+                {
+                    if (checkBoundingCurve(fEdges[eI]))
+                    {
+                        consistent = true;
+                    }
+                }
+
+                if (!consistent)
+                {
+                    nInconsistencies++;
+
+                    // Add to list
+                    faceErrors.append(error);
+
+                    // Accumulate error stats
+                    maxFaceError = Foam::max(maxFaceError, error);
+
+                    failedFaces.append
+                    (
+                        objectMap
+                        (
+                            fIndex,
+                            faceParents_[fIndex]
+                        )
+                    );
+                }
+            }
+        }
+    }
+
+    if (nInconsistencies)
+    {
+        Pout<< " Mapping errors: "
+            << " max cell error: " << maxCellError
+            << " max face error: " << maxFaceError
+            << endl;
+
+        if (debug || mappingOutput)
+        {
+            if (failedCells.size())
+            {
+                Pout<< " failedCells: " << endl;
+
+                forAll(failedCells, cellI)
+                {
+                    label index = failedCells[cellI].index();
+
+                    Pout<< "  Cell: " << index
+                        << "  Error: " << cellErrors[cellI]
+                        << endl;
+                }
+            }
+
+            if (failedFaces.size())
+            {
+                Pout<< " failedFaces: " << endl;
+
+                forAll(failedFaces, faceI)
+                {
+                    label index = failedFaces[faceI].index();
+                    label patchIndex = whichPatch(index);
+
+                    const polyBoundaryMesh& boundary = boundaryMesh();
+
+                    Pout<< "  Face: " << index
+                        << "  Patch: " << boundary[patchIndex].name()
+                        << "  Error: " << faceErrors[faceI]
+                        << endl;
+                }
+            }
+
+            if (debug > 3 || mappingOutput)
+            {
+                // Prepare lists
+                labelList objects;
+                scalarField weights;
+                vectorField centres;
+
+                if (failedCells.size())
+                {
+                    forAll(failedCells, cellI)
+                    {
+                        label cIndex = failedCells[cellI].index();
+
+                        cellAlgorithm.computeWeights
+                        (
+                            cIndex,
+                            0,
+                            cellParents_[cIndex],
+                            polyMesh::cellCells(),
+                            objects,
+                            weights,
+                            centres,
+                            true
+                        );
+
+                        computeCoupledWeights
+                        (
+                            cIndex,
+                            cellAlgorithm.dimension(),
+                            objects,
+                            weights,
+                            centres,
+                            true
+                        );
+
+                        // Clear lists
+                        objects.clear();
+                        weights.clear();
+                        centres.clear();
+                    }
+                }
+
+                if (failedFaces.size())
+                {
+                    forAll(failedFaces, faceI)
+                    {
+                        label fIndex = failedFaces[faceI].index();
+                        label patchIndex = whichPatch(fIndex);
+
+                        const polyBoundaryMesh& boundary = boundaryMesh();
+
+                        faceAlgorithm.computeWeights
+                        (
+                            fIndex,
+                            boundary[patchIndex].start(),
+                            faceParents_[fIndex],
+                            boundary[patchIndex].faceFaces(),
+                            objects,
+                            weights,
+                            centres,
+                            true
+                        );
+
+                        computeCoupledWeights
+                        (
+                            fIndex,
+                            faceAlgorithm.dimension(),
+                            objects,
+                            weights,
+                            centres,
+                            true
+                        );
+
+                        // Clear lists
+                        objects.clear();
+                        weights.clear();
+                        centres.clear();
+                    }
+                }
+            }
         }
     }
 }
@@ -144,16 +471,18 @@ void dynamicTopoFvMesh::computeMappingThread(void *argument)
     // Recast the pointers for the argument
     scalar& matchTol  = *(static_cast<scalar*>(thread->operator()(0)));
     bool& skipMapping = *(static_cast<bool*>(thread->operator()(1)));
-    label& faceStart  = *(static_cast<label*>(thread->operator()(2)));
-    label& faceSize   = *(static_cast<label*>(thread->operator()(3)));
-    label& cellStart  = *(static_cast<label*>(thread->operator()(4)));
-    label& cellSize   = *(static_cast<label*>(thread->operator()(5)));
+    bool& mappingOutput = *(static_cast<bool*>(thread->operator()(2)));
+    label& faceStart = *(static_cast<label*>(thread->operator()(3)));
+    label& faceSize = *(static_cast<label*>(thread->operator()(4)));
+    label& cellStart = *(static_cast<label*>(thread->operator()(5)));
+    label& cellSize = *(static_cast<label*>(thread->operator()(6)));
 
     // Now calculate addressing
     mesh.computeMapping
     (
         matchTol,
         skipMapping,
+        mappingOutput,
         faceStart, faceSize,
         cellStart, cellSize
     );
@@ -169,7 +498,8 @@ void dynamicTopoFvMesh::computeMappingThread(void *argument)
 void dynamicTopoFvMesh::threadedMapping
 (
     scalar matchTol,
-    bool skipMapping
+    bool skipMapping,
+    bool mappingOutput
 )
 {
     label nThreads = threader_->getNumThreads();
@@ -177,7 +507,7 @@ void dynamicTopoFvMesh::threadedMapping
     // If mapping is being skipped, issue a warning.
     if (skipMapping)
     {
-        Info << " *** Mapping is being skipped *** " << endl;
+        Info<< " *** Mapping is being skipped *** " << endl;
     }
 
     // Check if single-threaded
@@ -187,6 +517,7 @@ void dynamicTopoFvMesh::threadedMapping
         (
             matchTol,
             skipMapping,
+            mappingOutput,
             0, facesFromFaces_.size(),
             0, cellsFromCells_.size()
         );
@@ -212,8 +543,8 @@ void dynamicTopoFvMesh::threadedMapping
 
     if (debug > 2)
     {
-        Info << " Mapping Faces: " << index[0] << endl;
-        Info << " Mapping Cells: " << index[1] << endl;
+        Pout<< " Mapping Faces: " << index[0] << nl
+            << " Mapping Cells: " << index[1] << endl;
     }
 
     forAll(index, indexI)
@@ -234,8 +565,8 @@ void dynamicTopoFvMesh::threadedMapping
 
         if (debug > 2)
         {
-            Info << " Load starts: " << tStarts[indexI] << endl;
-            Info << " Load sizes: " << tSizes[indexI] << endl;
+            Pout<< " Load starts: " << tStarts[indexI] << nl
+                << " Load sizes: " << tSizes[indexI] << endl;
         }
     }
 
@@ -243,7 +574,7 @@ void dynamicTopoFvMesh::threadedMapping
     forAll(hdl, i)
     {
         // Size up the argument list
-        hdl[i].setSize(6);
+        hdl[i].setSize(7);
 
         // Set match tolerance
         hdl[i].set(0, &matchTol);
@@ -251,25 +582,26 @@ void dynamicTopoFvMesh::threadedMapping
         // Set the skipMapping flag
         hdl[i].set(1, &skipMapping);
 
+        // Set the mappingOutput flag
+        hdl[i].set(2, &mappingOutput);
+
         // Set the start/size indices
-        hdl[i].set(2, &(tStarts[0][i]));
-        hdl[i].set(3, &(tSizes[0][i]));
-        hdl[i].set(4, &(tStarts[1][i]));
-        hdl[i].set(5, &(tSizes[1][i]));
+        hdl[i].set(3, &(tStarts[0][i]));
+        hdl[i].set(4, &(tSizes[0][i]));
+        hdl[i].set(5, &(tStarts[1][i]));
+        hdl[i].set(6, &(tSizes[1][i]));
     }
 
     // Prior to multi-threaded operation,
     // force calculation of demand-driven data.
     polyMesh::cells();
     primitiveMesh::cellCells();
-    primitiveMesh::cellCentres();
 
     const polyBoundaryMesh& boundary = boundaryMesh();
 
     forAll(boundary, patchI)
     {
         boundary[patchI].faceFaces();
-        boundary[patchI].faceCentres();
     }
 
     // Execute threads in linear sequence
@@ -277,130 +609,6 @@ void dynamicTopoFvMesh::threadedMapping
 }
 
 
-// Compute parents for inverse-distance weighting
-void dynamicTopoFvMesh::computeParents
-(
-    const label index,
-    const labelList& mapCandidates,
-    const labelListList& oldNeighbourList,
-    const vectorField& oldCentres,
-    const label dimension,
-    labelList& parents
-) const
-{
-    if (parents.size())
-    {
-        FatalErrorIn
-        (
-            "\n\n"
-            "void dynamicTopoFvMesh::computeParents\n"
-            "(\n"
-            "    const label index,\n"
-            "    const labelList& mapCandidates,\n"
-            "    const labelListList& oldNeighbourList,\n"
-            "    const vectorField& oldCentres,\n"
-            "    const label dimension,\n"
-            "    labelList& parents\n"
-            ") const\n"
-        )
-            << " Addressing has already been calculated." << nl
-            << " Index: " << index << nl
-            << " Type: " << (dimension == 2 ? "Face" : "Cell") << nl
-            << " mapCandidates: " << mapCandidates << nl
-            << " Parents: " << parents << nl
-            << abort(FatalError);
-    }
-
-    // Figure out the patch offset and centre
-    label offset = -1;
-    vector centre = vector::zero;
-
-    if (dimension == 2)
-    {
-        offset = boundaryMesh()[whichPatch(index)].start();
-
-        centre = faces_[index].centre(oldPoints_);
-    }
-    else
-    if (dimension == 3)
-    {
-        offset = 0;
-        scalar dummyVol = 0.0;
-
-        meshOps::cellCentreAndVolume
-        (
-            index,
-            oldPoints_,
-            faces_,
-            cells_,
-            owner_,
-            centre,
-            dummyVol
-        );
-    }
-
-    // Maintain a check-list
-    labelHashSet checked;
-
-    // Insert candidates first
-    forAll(mapCandidates, indexI)
-    {
-        checked.insert(mapCandidates[indexI] - offset);
-    }
-
-    // Loop for three outward levels from candidates
-    for (label i = 0; i < 3; i++)
-    {
-        // Fetch the set of candidates
-        const labelList checkList = checked.toc();
-
-        forAll(checkList, indexI)
-        {
-            const labelList& oldNei = oldNeighbourList[checkList[indexI]];
-
-            forAll(oldNei, entityI)
-            {
-                if (!checked.found(oldNei[entityI]))
-                {
-                    checked.insert(oldNei[entityI]);
-                }
-            }
-        }
-    }
-
-    // Loop through accumulated candidates and fetch the nearest one.
-    scalar minDist = GREAT;
-    label minLocation = -1;
-
-    const labelList checkList = checked.toc();
-
-    forAll(checkList, indexI)
-    {
-        scalar dist = magSqr(oldCentres[checkList[indexI]] - centre);
-
-        if (dist < minDist)
-        {
-            minDist = dist;
-            minLocation = checkList[indexI];
-        }
-    }
-
-    // Set the final list
-    const labelList& neiList = oldNeighbourList[minLocation];
-
-    parents.setSize(neiList.size() + 1, -1);
-
-    // Fill indices
-    forAll(neiList, indexI)
-    {
-        parents[indexI] = neiList[indexI] + offset;
-    }
-
-    // Set final index
-    parents[neiList.size()] = minLocation + offset;
-}
-
-
 // Set fill-in mapping information for a particular cell
 void dynamicTopoFvMesh::setCellMapping
 (
@@ -413,9 +621,9 @@ void dynamicTopoFvMesh::setCellMapping
     {
         if (debug > 3)
         {
-            Info << "Inserting mapping cell: " << cIndex << nl
-                 << " mapCells: " << mapCells
-                 << endl;
+            Pout<< "Inserting mapping cell: " << cIndex
+                << " mapCells: " << mapCells
+                << endl;
         }
 
         // Insert index into the list, and overwrite if necessary
@@ -445,7 +653,7 @@ void dynamicTopoFvMesh::setCellMapping
     }
 
     // Update cell-parents information
-    labelHashSet masterCells;
+    DynamicList<label> masterCells(5);
 
     forAll(mapCells, cellI)
     {
@@ -456,7 +664,10 @@ void dynamicTopoFvMesh::setCellMapping
 
         if (mapCells[cellI] < nOldCells_)
         {
-            masterCells.insert(mapCells[cellI]);
+            if (findIndex(masterCells, mapCells[cellI]) == -1)
+            {
+                masterCells.append(mapCells[cellI]);
+            }
         }
         else
         if (cellParents_.found(mapCells[cellI]))
@@ -465,12 +676,15 @@ void dynamicTopoFvMesh::setCellMapping
 
             forAll(nParents, cI)
             {
-                masterCells.insert(nParents[cI]);
+                if (findIndex(masterCells, nParents[cI]) == -1)
+                {
+                    masterCells.append(nParents[cI]);
+                }
             }
         }
     }
 
-    cellParents_.set(cIndex, masterCells.toc());
+    cellParents_.set(cIndex, masterCells);
 }
 
 
@@ -482,13 +696,33 @@ void dynamicTopoFvMesh::setFaceMapping
 )
 {
     label patch = whichPatch(fIndex);
+    label neiProc = getNeighbourProcessor(patch);
 
     if (debug > 3)
     {
-        Info << "Inserting mapping face: " << fIndex << nl
-             << " patch: " << patch << nl
-             << " mapFaces: " << mapFaces
-             << endl;
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        word pName;
+
+        if (patch == -1)
+        {
+            pName = "Internal";
+        }
+        else
+        if (patch < boundary.size())
+        {
+            pName = boundaryMesh()[patch].name();
+        }
+        else
+        {
+            pName = "New patch: " + Foam::name(patch);
+        }
+
+        Pout<< "Inserting mapping face: " << fIndex
+            << " patch: " << pName
+            << " mapFaces: " << mapFaces
+            << " neiProc: "  << neiProc
+            << endl;
     }
 
     bool foundError = false;
@@ -500,15 +734,16 @@ void dynamicTopoFvMesh::setFaceMapping
         foundError = true;
     }
 
-    // Check to ensure that boundary faces map
-    // only from other faces on the same patch
-    if (patch > -1 && mapFaces.empty())
+    // Check to ensure that mapFaces is non-empty for physical patches
+    if (patch > -1 && mapFaces.empty() && neiProc == -1)
     {
         foundError = true;
     }
 
     if (foundError)
     {
+        writeVTK("mapFace_" + Foam::name(fIndex), fIndex, 2);
+
         FatalErrorIn
         (
             "\n"
@@ -524,7 +759,8 @@ void dynamicTopoFvMesh::setFaceMapping
             << "    2. Mapping specified for an internal face, " << nl
             << "       when none was expected." << nl << nl
             << " Face: " << fIndex << nl
-            << " Patch: " << patch << nl
+            << " Patch: "
+            << (patch > -1 ? boundaryMesh()[patch].name() : "Internal") << nl
             << " Owner: " << owner_[fIndex] << nl
             << " Neighbour: " << neighbour_[fIndex] << nl
             << " mapFaces: " << mapFaces << nl
@@ -556,14 +792,14 @@ void dynamicTopoFvMesh::setFaceMapping
         facesFromFaces_[index].masterObjects() = labelList(0);
     }
 
-    // For internal faces, set dummy maps / weights, and bail out
-    if (patch == -1)
+    // For internal / processor faces, bail out
+    if (patch == -1 || neiProc > -1)
     {
         return;
     }
 
     // Update face-parents information
-    labelHashSet masterFaces;
+    DynamicList<label> masterFaces(5);
 
     forAll(mapFaces, faceI)
     {
@@ -574,7 +810,10 @@ void dynamicTopoFvMesh::setFaceMapping
 
         if (mapFaces[faceI] < nOldFaces_)
         {
-            masterFaces.insert(mapFaces[faceI]);
+            if (findIndex(masterFaces, mapFaces[faceI]) == -1)
+            {
+                masterFaces.append(mapFaces[faceI]);
+            }
         }
         else
         if (faceParents_.found(mapFaces[faceI]))
@@ -583,12 +822,15 @@ void dynamicTopoFvMesh::setFaceMapping
 
             forAll(nParents, fI)
             {
-                masterFaces.insert(nParents[fI]);
+                if (findIndex(masterFaces, nParents[fI]) == -1)
+                {
+                    masterFaces.append(nParents[fI]);
+                }
             }
         }
     }
 
-    faceParents_.set(fIndex, masterFaces.toc());
+    faceParents_.set(fIndex, masterFaces);
 }
 
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
index b309283b0..2ca448140 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "objectMap.H"
+#include "coupledInfo.H"
 #include "dynamicTopoFvMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -51,10 +52,10 @@ void dynamicTopoFvMesh::reOrderPoints
     {
         if (threaded)
         {
-            Info << "Thread: " << self() << ": ";
+            Info<< "Thread: " << self() << ": ";
         }
 
-        Info << "ReOrdering points..." << flush;
+        Info<< "ReOrdering points..." << flush;
     }
 
     // Allocate for the mapping information
@@ -204,6 +205,52 @@ void dynamicTopoFvMesh::reOrderPoints
     // Reset all zones
     pointZones.updateMesh();
 
+    // Loop through all local coupling maps, and renumber points.
+    forAll(patchCoupling_, patchI)
+    {
+        if (!patchCoupling_(patchI))
+        {
+            continue;
+        }
+
+        const coupleMap& cMap = patchCoupling_[patchI].map();
+
+        // Obtain references
+        Map<label>& mtsMap = cMap.entityMap(coupleMap::POINT);
+
+        Map<label> newMtsMap, newStmMap;
+
+        forAllIter(Map<label>, mtsMap, pIter)
+        {
+            label newMaster = -1, newSlave = -1;
+
+            if (pIter.key() < nOldPoints_)
+            {
+                newMaster = reversePointMap_[pIter.key()];
+            }
+            else
+            {
+                newMaster = addedPointRenumbering_[pIter.key()];
+            }
+
+            if (pIter() < nOldPoints_)
+            {
+                newSlave = reversePointMap_[pIter()];
+            }
+            else
+            {
+                newSlave = addedPointRenumbering_[pIter()];
+            }
+
+            // Update the map.
+            newMtsMap.insert(newMaster, newSlave);
+            newStmMap.insert(newSlave, newMaster);
+        }
+
+        // Overwrite the old maps.
+        cMap.transferMaps(coupleMap::POINT, newMtsMap, newStmMap);
+    }
+
     // Clear local point copies
     points_.clear();
     oldPoints_.clear();
@@ -214,7 +261,7 @@ void dynamicTopoFvMesh::reOrderPoints
 
     if (debug)
     {
-        Info << "Done." << endl;
+        Info<< "Done." << endl;
     }
 }
 
@@ -274,10 +321,10 @@ void dynamicTopoFvMesh::reOrderEdges
     {
         if (threaded)
         {
-            Info << "Thread: " << self() << ": ";
+            Info<< "Thread: " << self() << ": ";
         }
 
-        Info << "ReOrdering edges..." << flush;
+        Info<< "ReOrdering edges..." << flush;
     }
 
     // Allocate for mapping information
@@ -286,10 +333,8 @@ void dynamicTopoFvMesh::reOrderEdges
     label edgeInOrder = 0, allEdges = edges_.size();
     edgeList oldEdges(allEdges);
     labelListList oldEdgeFaces(allEdges);
-    labelListList oldEdgePoints(allEdges);
 
     addedEdgeRenumbering_.clear();
-    Map<label> addedEdgeReverseRenumbering;
 
     // Transfer old edge-based lists, and clear them
     forAll(edges_, edgeI)
@@ -300,20 +345,10 @@ void dynamicTopoFvMesh::reOrderEdges
 
     edges_.setSize(nEdges_); edgeFaces_.setSize(nEdges_);
 
-    if (!twoDMesh_)
-    {
-        forAll(edgePoints_, edgeI)
-        {
-            oldEdgePoints[edgeI].transfer(edgePoints_[edgeI]);
-        }
-
-        edgePoints_.setSize(nEdges_);
-    }
-
     // Keep track of inserted boundary edge indices
     labelList boundaryPatchIndices(edgePatchStarts_);
 
-    // Loop through all edges and add internal ones first
+    // Loop through all edges and add them
     forAll(oldEdges, edgeI)
     {
         // Ensure that we're adding valid edges
@@ -325,8 +360,10 @@ void dynamicTopoFvMesh::reOrderEdges
         // Determine which patch this edge belongs to
         label patch = whichEdgePatch(edgeI);
 
-        // Update maps for boundary edges. Edge insertion for
-        // boundaries will be done after internal edges.
+        // Obtain references
+        edge& thisEdge = oldEdges[edgeI];
+        labelList& thisEF = oldEdgeFaces[edgeI];
+
         if (patch >= 0)
         {
             label bEdgeIndex = boundaryPatchIndices[patch]++;
@@ -339,18 +376,20 @@ void dynamicTopoFvMesh::reOrderEdges
             }
             else
             {
-                addedEdgeRenumbering_.insert(edgeI, bEdgeIndex);
-                addedEdgeReverseRenumbering.insert(bEdgeIndex, edgeI);
-
                 edgeMap_[bEdgeIndex] = -1;
+                addedEdgeRenumbering_.insert(edgeI, bEdgeIndex);
             }
+
+            // Insert entities into local lists...
+            edges_[bEdgeIndex] = thisEdge;
+            edgeFaces_[bEdgeIndex] = thisEF;
+
+            // Insert entities into mesh-reset lists
+            edges[bEdgeIndex] = thisEdge;
+            edgeFaces[bEdgeIndex].transfer(thisEF);
         }
         else
         {
-            // Obtain references
-            edge& thisEdge = oldEdges[edgeI];
-            labelList& thisEF = oldEdgeFaces[edgeI];
-
             // Renumber internal edges and add normally.
             if (edgeI < nOldEdges_)
             {
@@ -370,46 +409,10 @@ void dynamicTopoFvMesh::reOrderEdges
             edges[edgeInOrder] = thisEdge;
             edgeFaces[edgeInOrder].transfer(thisEF);
 
-            if (!twoDMesh_)
-            {
-                edgePoints_[edgeInOrder].transfer(oldEdgePoints[edgeI]);
-            }
-
             edgeInOrder++;
         }
     }
 
-    // All internal edges have been inserted. Now insert boundary edges.
-    label oldIndex;
-
-    for(label i = nInternalEdges_; i < nEdges_; i++)
-    {
-        if (edgeMap_[i] == -1)
-        {
-            // This boundary edge was added during the topology change
-            oldIndex = addedEdgeReverseRenumbering[i];
-        }
-        else
-        {
-            oldIndex = edgeMap_[i];
-        }
-
-        // Insert entities into local Lists...
-        edges_[edgeInOrder] = oldEdges[oldIndex];
-        edgeFaces_[edgeInOrder] = oldEdgeFaces[oldIndex];
-
-        // Insert entities into mesh-reset lists
-        edges[edgeInOrder] = oldEdges[oldIndex];
-        edgeFaces[edgeInOrder].transfer(oldEdgeFaces[oldIndex]);
-
-        if (!twoDMesh_)
-        {
-            edgePoints_[edgeInOrder].transfer(oldEdgePoints[oldIndex]);
-        }
-
-        edgeInOrder++;
-    }
-
     // Now that we're done with edges, unlock it
     if (threaded)
     {
@@ -417,15 +420,15 @@ void dynamicTopoFvMesh::reOrderEdges
     }
 
     // Final check to ensure everything went okay
-    if (edgeInOrder != nEdges_)
+    if (edgeInOrder != nInternalEdges_)
     {
         FatalErrorIn("dynamicTopoFvMesh::reOrderEdges()") << nl
-                << " Algorithm did not visit every edge in the mesh."
-                << " Something's messed up." << nl
-                << abort(FatalError);
+            << " Algorithm did not visit every internal edge in the mesh."
+            << " Something's messed up." << nl
+            << abort(FatalError);
     }
 
-    // Renumber all edges / edgePoints with updated point information
+    // Renumber all edges with updated point information
     label pIndex = -1;
 
     if (threaded)
@@ -463,24 +466,6 @@ void dynamicTopoFvMesh::reOrderEdges
 
         thisEdge[1] = pIndex;
         thisREdge[1] = pIndex;
-
-        // Renumber edgePoints
-        if (!twoDMesh_)
-        {
-            labelList& ePoints = edgePoints_[edgeI];
-
-            forAll(ePoints, pointI)
-            {
-                if (ePoints[pointI] < nOldPoints_)
-                {
-                    ePoints[pointI] = reversePointMap_[ePoints[pointI]];
-                }
-                else
-                {
-                    ePoints[pointI] = addedPointRenumbering_[ePoints[pointI]];
-                }
-            }
-        }
     }
 
     if (threaded)
@@ -553,11 +538,56 @@ void dynamicTopoFvMesh::reOrderEdges
     {
         // Invert edges to obtain pointEdges
         pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
+
+        // Loop through all local coupling maps, and renumber edges.
+        forAll(patchCoupling_, patchI)
+        {
+            if (!patchCoupling_(patchI))
+            {
+                continue;
+            }
+
+            // Obtain references
+            const coupleMap& cMap = patchCoupling_[patchI].map();
+            const Map<label>& mtsMap = cMap.entityMap(coupleMap::EDGE);
+
+            Map<label> newMtsMap, newStmMap;
+
+            forAllConstIter(Map<label>, mtsMap, mIter)
+            {
+                label newMaster = -1, newSlave = -1;
+
+                if (mIter.key() < nOldEdges_)
+                {
+                    newMaster = reverseEdgeMap_[mIter.key()];
+                }
+                else
+                {
+                    newMaster = addedEdgeRenumbering_[mIter.key()];
+                }
+
+                if (mIter() < nOldEdges_)
+                {
+                    newSlave = reverseEdgeMap_[mIter()];
+                }
+                else
+                {
+                    newSlave = addedEdgeRenumbering_[mIter()];
+                }
+
+                // Update the map.
+                newMtsMap.insert(newMaster, newSlave);
+                newStmMap.insert(newSlave, newMaster);
+            }
+
+            // Overwrite the old maps.
+            cMap.transferMaps(coupleMap::EDGE, newMtsMap, newStmMap);
+        }
     }
 
     if (debug)
     {
-        Info << "Done." << endl;
+        Info<< "Done." << endl;
     }
 }
 
@@ -624,10 +654,10 @@ void dynamicTopoFvMesh::reOrderFaces
     {
         if (threaded)
         {
-            Info << "Thread: " << self() << ": ";
+            Info<< "Thread: " << self() << ": ";
         }
 
-        Info << "ReOrdering faces..." << flush;
+        Info<< "ReOrdering faces..." << flush;
     }
 
     // Allocate for mapping information
@@ -639,6 +669,9 @@ void dynamicTopoFvMesh::reOrderFaces
     labelListList oldFaceEdges(allFaces);
 
     addedFaceRenumbering_.clear();
+
+    // Track reverse renumbering for added faces.
+    //  - Required during coupled patch re-ordering.
     Map<label> addedFaceReverseRenumbering;
 
     // Make a copy of the old face-based lists, and clear them
@@ -709,7 +742,6 @@ void dynamicTopoFvMesh::reOrderFaces
 
     // Handle boundaries first. If any coupled interfaces need to be
     // updated, they can be reshuffled after interior faces are done.
-    // Update maps for boundaries now.
     for (label faceI = nOldInternalFaces_; faceI < allFaces; faceI++)
     {
         if (visited[faceI] == -1)
@@ -725,18 +757,46 @@ void dynamicTopoFvMesh::reOrderFaces
             }
             else
             {
-                addedFaceRenumbering_.insert(faceI, bFaceIndex);
-
-                addedFaceReverseRenumbering.insert(bFaceIndex, faceI);
-
                 faceMap_[bFaceIndex] = -1;
+                addedFaceRenumbering_.insert(faceI, bFaceIndex);
+                addedFaceReverseRenumbering.insert(bFaceIndex, faceI);
             }
 
+            // Renumber owner
+            label ownerRenumber =
+            (
+                oldOwner[faceI] < nOldCells_
+              ? reverseCellMap_[oldOwner[faceI]]
+              : addedCellRenumbering_[oldOwner[faceI]]
+            );
+
+            // Insert entities into local lists...
+            owner_[bFaceIndex] = ownerRenumber;
+            neighbour_[bFaceIndex] = -1;
+            faces_[bFaceIndex] = oldFaces[faceI];
+            faceEdges_[bFaceIndex] = oldFaceEdges[faceI];
+
+            // Insert entities into mesh-reset lists...
+            owner[bFaceIndex] = ownerRenumber;
+            faces[bFaceIndex].transfer(oldFaces[faceI]);
+            faceEdges[bFaceIndex].transfer(oldFaceEdges[faceI]);
+
             // Mark this face as visited
             visited[faceI] = 0;
         }
     }
 
+    // Prepare centres and anchors for coupled interfaces
+    List<pointField> centres(nPatches_), anchors(nPatches_);
+
+    // Now that points and boundary faces are up-to-date,
+    // send and receive centres and anchor points for coupled patches
+    initCoupledBoundaryOrdering
+    (
+        centres,
+        anchors
+    );
+
     // Upper-triangular ordering of internal faces:
 
     // Insertion cannot be done in one go as the faces need to be
@@ -885,43 +945,105 @@ void dynamicTopoFvMesh::reOrderFaces
         }
     }
 
-    // All internal faces have been inserted. Now insert boundary faces.
-    label oldIndex;
+    // Prepare faceMaps and rotations for coupled interfaces
+    labelListList patchMaps(nPatches_), rotations(nPatches_);
 
-    for (label i = nInternalFaces_; i < nFaces_; i++)
-    {
-        if (faceMap_[i] == -1)
-        {
-            // This boundary face was added during the topology change
-            oldIndex = addedFaceReverseRenumbering[i];
-        }
-        else
-        {
-            oldIndex = faceMap_[i];
-        }
-
-        // Renumber owner/neighbour
-        label ownerRenumber =
+    // Now compute patchMaps for coupled interfaces
+    bool anyChange =
+    (
+        syncCoupledBoundaryOrdering
         (
-            oldOwner[oldIndex] < nOldCells_
-          ? reverseCellMap_[oldOwner[oldIndex]]
-          : addedCellRenumbering_[oldOwner[oldIndex]]
-        );
+            centres,
+            anchors,
+            patchMaps,
+            rotations
+        )
+    );
 
-        // Insert entities into local listsLists...
-        faces_[faceInOrder] = oldFaces[oldIndex];
-        owner_[faceInOrder] = ownerRenumber;
-        neighbour_[faceInOrder] = -1;
-        faceEdges_[faceInOrder] = oldFaceEdges[oldIndex];
+    if (anyChange)
+    {
+        forAll(patchMaps, pI)
+        {
+            const labelList& patchMap = patchMaps[pI];
 
-        // Insert entities into mesh-reset lists
-        // NOTE: From OF-1.5 onwards, neighbour array
-        //       does not store -1 for boundary faces
-        faces[faceInOrder].transfer(oldFaces[oldIndex]);
-        owner[faceInOrder] = ownerRenumber;
-        faceEdges[faceInOrder].transfer(oldFaceEdges[oldIndex]);
+            if (patchMap.size())
+            {
+                // Faces in this patch need to be shuffled
+                label pStart = patchStarts_[pI];
 
-        faceInOrder++;
+                forAll(patchMap, fI)
+                {
+                    label oldPos = fI + pStart;
+                    label newPos = patchMap[fI] + pStart;
+
+                    // Rotate the face in-place
+                    const face& oldFace = faces_[oldPos];
+
+                    // Copy the old face, and rotate if necessary
+                    face newFace(oldFace);
+                    label nPos = rotations[pI][fI];
+
+                    if (nPos != 0)
+                    {
+                        forAll(oldFace, fpI)
+                        {
+                            label nfpI = (fpI + nPos) % oldFace.size();
+
+                            if (nfpI < 0)
+                            {
+                                nfpI += oldFace.size();
+                            }
+
+                            newFace[nfpI] = oldFace[fpI];
+                        }
+                    }
+
+                    // Map to new locations, using the
+                    // 'old' lists as temporaries.
+                    //  - All boundary neighbours are '-1',
+                    //    so use that as a faceMap temporary
+                    oldNeighbour[newPos] = faceMap_[oldPos];
+
+                    // Check if this face was added
+                    if (faceMap_[oldPos] == -1)
+                    {
+                        // Fetch the index for the new face
+                        label addedIndex = addedFaceReverseRenumbering[oldPos];
+
+                        // Renumber for the added index
+                        addedFaceRenumbering_[addedIndex] = newPos;
+                    }
+                    else
+                    {
+                        // Fetch the index for the existing face
+                        label existIndex = faceMap_[oldPos];
+
+                        // Renumber the reverse map
+                        reverseFaceMap_[existIndex] = newPos;
+                    }
+
+                    oldOwner[newPos] = owner_[oldPos];
+                    oldFaces[newPos].transfer(newFace);
+                    oldFaceEdges[newPos].transfer(faceEdges_[oldPos]);
+                }
+
+                // Now copy / transfer back to original lists
+                forAll(patchMap, fI)
+                {
+                    label index = (fI + pStart);
+
+                    faceMap_[index] = oldNeighbour[index];
+
+                    owner_[index] = oldOwner[index];
+                    faces_[index] = oldFaces[index];
+                    faceEdges_[index] = oldFaceEdges[index];
+
+                    owner[index] = oldOwner[index];
+                    faces[index].transfer(oldFaces[index]);
+                    faceEdges[index].transfer(oldFaceEdges[index]);
+                }
+            }
+        }
     }
 
     // Now that we're done with faces, unlock it
@@ -1104,9 +1226,54 @@ void dynamicTopoFvMesh::reOrderFaces
     // Reset all zones
     faceZones.updateMesh();
 
+    // Loop through all local coupling maps, and renumber faces.
+    forAll(patchCoupling_, patchI)
+    {
+        if (!patchCoupling_(patchI))
+        {
+            continue;
+        }
+
+        // Obtain references
+        const coupleMap& cMap = patchCoupling_[patchI].map();
+        const Map<label>& mtsMap = cMap.entityMap(coupleMap::FACE);
+
+        Map<label> newMtsMap, newStmMap;
+
+        forAllConstIter(Map<label>, mtsMap, mIter)
+        {
+            label newMaster = -1, newSlave = -1;
+
+            if (mIter.key() < nOldFaces_)
+            {
+                newMaster = reverseFaceMap_[mIter.key()];
+            }
+            else
+            {
+                newMaster = addedFaceRenumbering_[mIter.key()];
+            }
+
+            if (mIter() < nOldFaces_)
+            {
+                newSlave = reverseFaceMap_[mIter()];
+            }
+            else
+            {
+                newSlave = addedFaceRenumbering_[mIter()];
+            }
+
+            // Update the map.
+            newMtsMap.insert(newMaster, newSlave);
+            newStmMap.insert(newSlave, newMaster);
+        }
+
+        // Overwrite the old maps.
+        cMap.transferMaps(coupleMap::FACE, newMtsMap, newStmMap);
+    }
+
     if (debug)
     {
-        Info << "Done." << endl;
+        Info<< "Done." << endl;
     }
 }
 
@@ -1184,10 +1351,10 @@ void dynamicTopoFvMesh::reOrderCells
     {
         if (threaded)
         {
-            Info << "Thread: " << self() << ": ";
+            Info<< "Thread: " << self() << ": ";
         }
 
-        Info << "ReOrdering cells..." << flush;
+        Info<< "ReOrdering cells..." << flush;
     }
 
     // Allocate for mapping information
@@ -1507,7 +1674,7 @@ void dynamicTopoFvMesh::reOrderCells
 
     if (debug)
     {
-        Info << "Done." << endl;
+        Info<< "Done." << endl;
     }
 }
 
@@ -1558,47 +1725,53 @@ void dynamicTopoFvMesh::reOrderMesh
 {
     if (debug)
     {
-        Info << endl;
-        Info << "=================" << endl;
-        Info << " Mesh reOrdering " << endl;
-        Info << "=================" << endl;
-        Info << "Mesh Info [n]:" << endl;
-        Info << "Points: " << nOldPoints_ << endl;
-        Info << "Edges: " << nOldEdges_ << endl;
-        Info << "Faces: " << nOldFaces_ << endl;
-        Info << "Cells: " << nOldCells_ << endl;
-        Info << "Internal Edges: " << nOldInternalEdges_ << endl;
-        Info << "Internal Faces: " << nOldInternalFaces_ << endl;
+        Info<< nl
+            << "=================" << nl
+            << " Mesh reOrdering " << nl
+            << "=================" << nl
+            << " Mesh Info [n]:" << nl
+            << " Points: " << nOldPoints_ << nl
+            << " Edges: " << nOldEdges_ << nl
+            << " Faces: " << nOldFaces_ << nl
+            << " Cells: " << nOldCells_ << nl
+            << " Internal Edges: " << nOldInternalEdges_ << nl
+            << " Internal Faces: " << nOldInternalFaces_ << nl
+            << " nPatches: " << nPatches_ << nl;
+
         if (debug > 1)
         {
-            Info << "Patch Starts [Face]: " << oldPatchStarts_ << endl;
-            Info << "Patch Sizes  [Face]: " << oldPatchSizes_ << endl;
-            Info << "Patch Starts [Edge]: " << oldEdgePatchStarts_ << endl;
-            Info << "Patch Sizes  [Edge]: " << oldEdgePatchSizes_ << endl;
+            Info<< " Patch Starts [Face]: " << oldPatchStarts_ << nl
+                << " Patch Sizes  [Face]: " << oldPatchSizes_ << nl
+                << " Patch Starts [Edge]: " << oldEdgePatchStarts_ << nl
+                << " Patch Sizes  [Edge]: " << oldEdgePatchSizes_ << nl;
         }
-        Info << "=================" << endl;
-        Info << "Mesh Info [n+1]:" << endl;
-        Info << "Points: " << nPoints_ << endl;
-        Info << "Edges: " << nEdges_ << endl;
-        Info << "Faces: " << nFaces_ << endl;
-        Info << "Cells: " << nCells_ << endl;
-        Info << "Internal Edges: " << nInternalEdges_ << endl;
-        Info << "Internal Faces: " << nInternalFaces_ << endl;
+
+        Info<< "=================" << nl
+            << " Mesh Info [n+1]:" << nl
+            << " Points: " << nPoints_ << nl
+            << " Edges: " << nEdges_ << nl
+            << " Faces: " << nFaces_ << nl
+            << " Cells: " << nCells_ << nl
+            << " Internal Edges: " << nInternalEdges_ << nl
+            << " Internal Faces: " << nInternalFaces_ << nl
+            << " nPatches: " << nPatches_ << nl;
+
         if (debug > 1)
         {
-            Info << "Patch Starts [Face]: " << patchStarts_ << endl;
-            Info << "Patch Sizes: [Face]: " << patchSizes_ << endl;
-            Info << "Patch Starts [Edge]: " << edgePatchStarts_ << endl;
-            Info << "Patch Sizes: [Edge]: " << edgePatchSizes_ << endl;
+            Info<< " Patch Starts [Face]: " << patchStarts_ << nl
+                << " Patch Sizes: [Face]: " << patchSizes_ << nl
+                << " Patch Starts [Edge]: " << edgePatchStarts_ << nl
+                << " Patch Sizes: [Edge]: " << edgePatchSizes_ << nl;
         }
-        Info << "=================" << endl;
+
+        Info<< "=================" << endl;
 
         // Check connectivity structures for consistency
         // before entering the reOrdering phase.
         checkConnectivity();
     }
 
-    if (threader_->multiThreaded())
+    if (threader_->multiThreaded() && !Pstream::parRun())
     {
         // Initialize multi-threaded reOrdering
         threadedMeshReOrdering
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
index 1af71df22..bc50741d5 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
@@ -42,7 +42,6 @@ defineTypeNameAndDebug(eMesh, 0);
 
 word eMesh::meshSubDir = "eMesh";
 
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void eMesh::clearGeom() const
@@ -65,8 +64,6 @@ void eMesh::clearAddressing() const
 
     edges_.clear();
 
-    deleteDemandDrivenData(pePtr_);
-    deleteDemandDrivenData(epPtr_);
     deleteDemandDrivenData(fePtr_);
     deleteDemandDrivenData(efPtr_);
 }
@@ -149,8 +146,6 @@ eMesh::eMesh(const polyMesh& pMesh, const word& subDir)
         ),
         *this
     ),
-    pePtr_(NULL),
-    epPtr_(NULL),
     fePtr_(NULL),
     efPtr_(NULL)
 {
@@ -393,28 +388,6 @@ void eMesh::setInstance(const fileName& inst)
 }
 
 
-const labelListList& eMesh::pointEdges() const
-{
-    if (!pePtr_)
-    {
-        calcPointEdges();
-    }
-
-    return *pePtr_;
-}
-
-
-const labelListList& eMesh::edgePoints() const
-{
-    if (!epPtr_)
-    {
-        calcEdgePoints();
-    }
-
-    return *epPtr_;
-}
-
-
 const labelListList& eMesh::faceEdges() const
 {
     if (!fePtr_)
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
index 576207678..580e164ec 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
@@ -80,12 +80,6 @@ class eMesh
             //- Mapping between ordered edge-data and regular edges.
             labelList reverseEdgeMap_;
 
-            //- Point-edges
-            mutable labelListList* pePtr_;
-
-            //- Edge-points
-            mutable labelListList* epPtr_;
-
             //- Face-edges
             mutable labelListIOList* fePtr_;
 
@@ -111,12 +105,6 @@ class eMesh
             //- Calculate ordered edges (and edgeFaces)
             void calcOrderedEdgeList();
 
-            //- Calculate ordered edgePoints
-            void calcEdgePoints() const;
-
-            //- Calculate point-edges
-            void calcPointEdges() const;
-
             //- Calculate face-edges
             void calcFaceEdges() const;
 
@@ -197,13 +185,6 @@ public:
 
         // Demand-driven data
 
-            //- Return constant reference to the pointEdges list
-            const labelListList& pointEdges() const;
-
-            //- Return constant reference to the edgePoints list
-            //- Valid for 3D tetrahedral meshes only.
-            const labelListList& edgePoints() const;
-
             //- Return constant reference to the faceEdges list
             const labelListList& faceEdges() const;
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
index 3bc135bc2..1e5623ad0 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
@@ -24,6 +24,8 @@ License
 
 Description
 
+    Demand-driven edge mesh data
+
 \*---------------------------------------------------------------------------*/
 
 #include "eMesh.H"
@@ -144,195 +146,6 @@ void eMesh::calcOrderedEdgeList()
     calcFaceEdges();
 }
 
-void eMesh::calcEdgePoints() const
-{
-    if (debug)
-    {
-        Info<< "void eMesh::calcEdgePoints() const : "
-            << "Calculating ordered edgePoints" << endl;
-    }
-
-    if (epPtr_)
-    {
-        FatalErrorIn
-        (
-            "void eMesh::calcEdgePoints() const"
-        )   << "edgePoints already allocated."
-            << abort(FatalError);
-    }
-
-    if (!efPtr_->size())
-    {
-        FatalErrorIn
-        (
-            "void eMesh::calcEdgePoints() const"
-        )   << "edgeFaces doesn't exist."
-            << abort(FatalError);
-    }
-
-    // Size the list
-    epPtr_ = new labelListList(nEdges_);
-    labelListList& edgePoints = *epPtr_;
-
-    // EdgePoints are ordered such that points appear in
-    // counter-clockwise direction around point[0] of the edge.
-    // If a boundary point is present, that must begin the list.
-    // NOTE: Will work only on tetrahedral meshes!
-
-    bool found;
-    label faceIndex = -1, cellIndex = -1;
-    const labelList& owner = mesh_.faceOwner();
-    const labelList& neighbour = mesh_.faceNeighbour();
-    const cellList& cells = mesh_.cells();
-    const faceList& faces = mesh_.faces();
-    const labelListList& eFaces = this->edgeFaces();
-
-    for (label eIndex=0; eIndex < nEdges_; eIndex++)
-    {
-        const edge& e = edges_[eIndex];
-        const labelList& eFace = eFaces[eIndex];
-
-        // Size the list
-        edgePoints[eIndex].setSize(eFace.size(), -1);
-
-        if (eIndex < nInternalEdges_)
-        {
-            // Pick the first face and start with that
-            faceIndex = eFace[0];
-        }
-        else
-        {
-            // Need to find a properly oriented start-face
-            forAll(eFace, faceI)
-            {
-                if
-                (
-                    (!mesh_.isInternalFace(eFace[faceI]))
-                 && (edgeDirection(faces[eFace[faceI]], e) == 1)
-                )
-                {
-                    faceIndex = eFace[faceI];
-                    break;
-                }
-            }
-        }
-
-        // Shuffle vertices to appear in CCW order
-        for (label j=0; j < eFace.size(); j++)
-        {
-            const face& f = faces[faceIndex];
-
-            // Add the isolated point
-            edgePoints[eIndex][j] = findIsolatedPoint(f, e);
-
-            // Figure out how this edge is oriented.
-            if (edgeDirection(f, e) == 1)
-            {
-                // Counter-clockwise. Pick the owner.
-                cellIndex = owner[faceIndex];
-            }
-            else
-            if (mesh_.isInternalFace(faceIndex))
-            {
-                // Clockwise. Pick the neighbour.
-                cellIndex = neighbour[faceIndex];
-            }
-            else
-            {
-                // Looks like we've hit a boundary face. Break out.
-                break;
-            }
-
-            const cell& cellToCheck = cells[cellIndex];
-
-            found = false;
-
-            // Assuming tet-cells,
-            // Loop through edgeFaces and get the next face
-            forAll(eFace, faceI)
-            {
-                if
-                (
-                    eFace[faceI] != faceIndex
-                 && eFace[faceI] == cellToCheck[0]
-                )
-                {
-                    faceIndex = cellToCheck[0];
-                    found = true; break;
-                }
-
-                if
-                (
-                    eFace[faceI] != faceIndex
-                 && eFace[faceI] == cellToCheck[1]
-                )
-                {
-                    faceIndex = cellToCheck[1];
-                    found = true; break;
-                }
-
-                if
-                (
-                    eFace[faceI] != faceIndex
-                 && eFace[faceI] == cellToCheck[2]
-                )
-                {
-                    faceIndex = cellToCheck[2];
-                    found = true; break;
-                }
-
-                if
-                (
-                    eFace[faceI] != faceIndex
-                 && eFace[faceI] == cellToCheck[3]
-                )
-                {
-                    faceIndex = cellToCheck[3];
-                    found = true; break;
-                }
-            }
-
-#           ifdef FULLDEBUG
-            if (!found)
-            {
-                // Something's terribly wrong
-                FatalErrorIn
-                (
-                    "void eMesh::calcEdgePoints() const"
-                )
-                << " Failed to determine a vertex ring. " << nl
-                << " edgeFaces connectivity is inconsistent. " << nl
-                << "Edge: " << eIndex << ":: " << e << nl
-                << "edgeFaces: " << eFace
-                << abort(FatalError);
-            }
-#           endif
-        }
-    }
-}
-
-
-void eMesh::calcPointEdges() const
-{
-    if (debug)
-    {
-        Info<< "void eMesh::calcPointEdges() const : "
-            << "Calculating PointEdges" << endl;
-    }
-
-    if (pePtr_)
-    {
-        FatalErrorIn
-        (
-            "void eMesh::calcPointEdges() const"
-        )   << "pePtr_ already allocated"
-            << abort(FatalError);
-    }
-
-    pePtr_ = new labelListList(mesh_.nPoints());
-    invertManyToMany(mesh_.nPoints(), edges(), *pePtr_);
-}
-
 
 void eMesh::calcFaceEdges() const
 {
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
index feb8c5439..f5508c962 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
@@ -80,16 +80,6 @@ ePatch::ePatch
     size_(readLabel(dict.lookup("size")))
 {}
 
-
-ePatch::ePatch(const ePatch& p)
-:
-    patchIdentifier(p, p.index()),
-    boundaryMesh_(p.boundaryMesh_),
-    start_(p.start()),
-    size_(p.size())
-{}
-
-
 ePatch::ePatch(const ePatch& p, const eBoundaryMesh& bm)
 :
     patchIdentifier(p, p.index()),
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
index 39743beaf..94813b5f0 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
@@ -69,6 +69,13 @@ private:
         //- Size of the patch
         label size_;
 
+        // Demand-driven private data
+
+
+    // Private Member Functions
+
+        //- Disallow construct as copy
+        ePatch(const ePatch&);
 
 protected:
 
@@ -163,9 +170,6 @@ public:
             const eBoundaryMesh& bm
         );
 
-        //- Construct as copy
-        ePatch(const ePatch&);
-
         //- Construct as copy, resetting the boundary mesh
         ePatch(const ePatch&, const eBoundaryMesh&);
 
@@ -185,7 +189,7 @@ public:
         );
 
 
-        //- Return a pointer to a new patch created
+        //- Return a pointer to a new patch created 
         // on freestore from dictionary
         static autoPtr<ePatch> New
         (
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
index 44ee279a6..5e7fed240 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
@@ -29,6 +29,7 @@ License
 #include "objectMap.H"
 #include "changeMap.H"
 #include "multiThreader.H"
+#include "coupledInfo.H"
 #include "dynamicTopoFvMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -43,6 +44,7 @@ namespace Foam
 //     1: Bisection was successful
 //    -1: Bisection failed since max number of topo-changes was reached.
 //    -2: Bisection failed since resulting quality would be unacceptable.
+//    -3: Bisection failed since edge was on a noRefinement patch.
 const changeMap dynamicTopoFvMesh::bisectQuadFace
 (
     const label fIndex,
@@ -63,7 +65,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     label tIndex = self();
 
     // Prepare the changeMaps
-    changeMap map, slaveMap;
+    changeMap map;
+    List<changeMap> slaveMaps;
+    bool bisectingSlave = false;
 
     if
     (
@@ -78,8 +82,10 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     }
 
     // Check if edgeRefinements are to be avoided on patch.
-    if (lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
+    if (baseMesh_.lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
     {
+        map.type() = -3;
+
         return map;
     }
 
@@ -93,7 +99,8 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             "(\n"
             "    const label fIndex,\n"
             "    const changeMap& masterMap,\n"
-            "    bool checkOnly\n"
+            "    bool checkOnly,\n"
+            "    bool forceOp\n"
             ")\n"
         )
             << " Invalid index: " << fIndex << nl
@@ -106,14 +113,16 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     face tmpQuadFace(4), tmpTriFace(3);
     labelList tmpQFEdges(4, -1), tmpTFEdges(3, -1);
     FixedList<label,7> newFaceIndex(-1), newEdgeIndex(-1);
-    FixedList<edge,4> commonEdges;
+    FixedList<edge,4> commonEdges(edge(-1, -1));
     FixedList<label,4> cornerEdgeIndex(-1), commonEdgeIndex(-1);
     FixedList<label,4> commonFaceIndex(-1);
     FixedList<label,2> newPointIndex(-1), newCellIndex(-1);
     FixedList<label,4> otherEdgeIndex(-1), otherEdgePoint(-1);
     FixedList<label,4> otherPointIndex(-1), nextToOtherPoint(-1);
-    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
-    FixedList<face,2>  c0BdyFace,  c0IntFace,  c1BdyFace,  c1IntFace;
+    FixedList<label,2> c0BdyIndex(-1), c0IntIndex(-1);
+    FixedList<label,2> c1BdyIndex(-1), c1IntIndex(-1);
+    FixedList<face,2> c0BdyFace(face(3)), c0IntFace(face(4));
+    FixedList<face,2> c1BdyFace(face(3)), c1IntFace(face(4));
 
     // Get the two cells on either side...
     label c0 = owner_[fIndex], c1 = neighbour_[fIndex];
@@ -169,66 +178,6 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         }
     }
 
-    if (debug > 1)
-    {
-        Info << nl << nl << "Face: " << fIndex
-             << ": " << faces_[fIndex] << " is to be bisected. " << endl;
-
-        label epIndex = whichPatch(fIndex);
-
-        Info << "Patch: ";
-
-        if (epIndex == -1)
-        {
-            Info << "Internal" << endl;
-        }
-        else
-        {
-            Info << boundaryMesh()[epIndex].name() << endl;
-        }
-
-        if (debug > 2)
-        {
-            Info << "Cell[0]: " << c0 << ": " << oldCells[0] << endl;
-
-            forAll(oldCells[0], faceI)
-            {
-                const labelList& fE = faceEdges_[oldCells[0][faceI]];
-
-                Info << oldCells[0][faceI] << ": "
-                     << faces_[oldCells[0][faceI]]
-                     << " fE: " << fE
-                     << endl;
-
-                forAll(fE, edgeI)
-                {
-                    const labelList& eF = edgeFaces_[fE[edgeI]];
-
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
-                }
-            }
-        }
-
-        // Write out VTK files prior to change
-        if (debug > 3)
-        {
-            labelList cellHull(2, -1);
-
-            cellHull[0] = owner_[fIndex];
-            cellHull[1] = neighbour_[fIndex];
-
-            writeVTK
-            (
-                Foam::name(fIndex)
-              + "_Bisect_0",
-                cellHull
-            );
-        }
-    }
-
     // Find the common-edge between the triangular boundary faces
     // and the face under consideration.
     meshOps::findCommonEdge
@@ -250,6 +199,332 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     commonEdges[0] = edges_[commonEdgeIndex[0]];
     commonEdges[1] = edges_[commonEdgeIndex[1]];
 
+    // If coupled modification is set, and this is a
+    // master edge, bisect its slaves as well.
+    bool localCouple = false, procCouple = false;
+
+    if (coupledModification_)
+    {
+        const label faceEnum = coupleMap::FACE;
+        const label pointEnum = coupleMap::POINT;
+
+        // Is this a locally coupled face (either master or slave)?
+        if (locallyCoupledEntity(fIndex, true))
+        {
+            localCouple = true;
+            procCouple = false;
+        }
+        else
+        if (processorCoupledEntity(fIndex))
+        {
+            procCouple = true;
+            localCouple = false;
+        }
+
+        if (localCouple && !procCouple)
+        {
+            // Determine the slave index.
+            label sIndex = -1, pIndex = -1;
+
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                    if ((sIndex = cMap.findSlave(faceEnum, fIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        break;
+                    }
+
+                    // The following bit happens only during the sliver
+                    // exudation process, since slave faces are
+                    // usually not added to the coupled face-stack.
+                    if ((sIndex = cMap.findMaster(faceEnum, fIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        // Notice that we are collapsing a slave face first.
+                        bisectingSlave = true;
+
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::bisectQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    const changeMap& masterMap,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Face: " << fIndex << ": " << faces_[fIndex] << nl
+                    << abort(FatalError);
+            }
+            else
+            {
+                // If we've found the slave, size up the list
+                meshOps::sizeUpList
+                (
+                    changeMap(),
+                    slaveMaps
+                );
+
+                // Save index and patch for posterity
+                slaveMaps[0].index() = sIndex;
+                slaveMaps[0].patchIndex() = pIndex;
+            }
+
+            if (debug > 1)
+            {
+                Pout<< nl << " >> Bisecting slave face: " << sIndex
+                    << " for master face: " << fIndex << endl;
+            }
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            // If this is a new entity, bail out for now.
+            // This will be handled at the next time-step.
+            if (fIndex >= nOldFaces_)
+            {
+                return map;
+            }
+
+            // Check slaves
+            forAll(procIndices_, pI)
+            {
+                // Fetch reference to subMesh
+                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupleMap& cMap = recvMesh.map();
+
+                label sIndex = -1;
+
+                if ((sIndex = cMap.findSlave(faceEnum, fIndex)) > -1)
+                {
+                    if (debug > 3)
+                    {
+                        Pout<< "Checking slave face: " << sIndex
+                            << " on proc: " << procIndices_[pI]
+                            << " for master face: " << fIndex
+                            << endl;
+                    }
+
+                    // Check if a lower-ranked processor is
+                    // handling this edge
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Face: " << fIndex
+                                << " is handled by proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Save index and patch for posterity
+                    slaveMaps[curIndex].index() = sIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+
+                    // Only one slave coupling is possible, so bail out
+                    break;
+                }
+            }
+        }
+        else
+        {
+            // Something's wrong with coupling maps
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::bisectQuadFace\n"
+                "(\n"
+                "    const label fIndex,\n"
+                "    const changeMap& masterMap,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp"
+                ")\n"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " localCouple: " << localCouple << nl
+                << " procCouple: " << procCouple << nl
+                << " Face: " << fIndex << ": " << faces_[fIndex] << nl
+                << abort(FatalError);
+        }
+
+        // Alias for convenience...
+        changeMap& slaveMap = slaveMaps[0];
+
+        label sIndex = slaveMap.index();
+        label pI = slaveMap.patchIndex();
+        const coupleMap* cMapPtr = NULL;
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        if (localCouple)
+        {
+            cMapPtr = &(patchCoupling_[pI].map());
+
+            // First check the slave for bisection feasibility.
+            slaveMap = bisectQuadFace(sIndex, changeMap(), true, forceOp);
+        }
+        else
+        if (procCouple)
+        {
+            cMapPtr = &(recvMeshes_[pI].map());
+
+            coupledInfo& recvMesh = recvMeshes_[pI];
+
+            // First check the slave for bisection feasibility.
+            slaveMap =
+            (
+                recvMesh.subMesh().bisectQuadFace
+                (
+                    sIndex,
+                    changeMap(),
+                    true,
+                    forceOp
+                )
+            );
+        }
+
+        // Turn it back on.
+        setCoupledModification();
+
+        if (slaveMap.type() <= 0)
+        {
+            // Slave couldn't perform bisection.
+            map.type() = -2;
+
+            return map;
+        }
+
+        // Save index and patch for posterity
+        slaveMap.index() = sIndex;
+        slaveMap.patchIndex() = pI;
+
+        // Alias for convenience..
+        const coupleMap& cMap = *cMapPtr;
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        // First check the master for bisection feasibility.
+        changeMap masterMap = bisectQuadFace(fIndex, changeMap(), true);
+
+        // Turn it back on.
+        setCoupledModification();
+
+        // Master couldn't perform bisection
+        if (masterMap.type() <= 0)
+        {
+            return masterMap;
+        }
+
+        // Fill the masterMap with points that
+        // we seek maps for...
+        FixedList<labelList, 2> slaveEdges(labelList(2, -1));
+
+        forAll(slaveEdges, edgeI)
+        {
+            labelList& slaveEdge = slaveEdges[edgeI];
+
+            // Renumber to slave indices
+            forAll(slaveEdge, pointI)
+            {
+                slaveEdge[pointI] =
+                (
+                    cMap.findSlave
+                    (
+                        pointEnum,
+                        commonEdges[edgeI][pointI]
+                    )
+                );
+            }
+
+            masterMap.addPoint(-1, slaveEdge);
+        }
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        if (localCouple)
+        {
+            // Bisect the local slave.
+            slaveMap = bisectQuadFace(sIndex, masterMap, false, forceOp);
+        }
+        else
+        {
+            coupledInfo& recvMesh = recvMeshes_[pI];
+
+            // Bisect the slave face
+            slaveMap =
+            (
+                recvMesh.subMesh().bisectQuadFace
+                (
+                    sIndex,
+                    masterMap,
+                    false,
+                    forceOp
+                )
+            );
+        }
+
+        // Turn coupledModification back on.
+        setCoupledModification();
+
+        // The final operation has to succeed.
+        if (slaveMap.type() <= 0)
+        {
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::bisectQuadFace\n"
+                "(\n"
+                "    const label fIndex,\n"
+                "    const changeMap& masterMap,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp"
+                ")\n"
+            )
+                << "Coupled topo-change for slave failed."
+                << " Master face: " << fIndex << nl
+                << " Slave face: " << sIndex << nl
+                << " Patch index: " << pI << nl
+                << " Type: " << slaveMap.type() << nl
+                << abort(FatalError);
+        }
+
+        // Save index and patch for posterity
+        slaveMap.index() = sIndex;
+        slaveMap.patchIndex() = pI;
+    }
+
     // Are we performing only checks?
     if (checkOnly)
     {
@@ -257,6 +532,78 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         return map;
     }
 
+    if (debug > 1)
+    {
+        Pout<< nl << nl
+            << "Face: " << fIndex
+            << ": " << faces_[fIndex]
+            << " is to be bisected. " << endl;
+
+        if (debug > 2)
+        {
+            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " coupledModification: " << coupledModification_ << nl;
+
+            const polyBoundaryMesh& boundary = boundaryMesh();
+
+            label epIndex = whichPatch(fIndex);
+
+            Pout<< " Patch: ";
+
+            if (epIndex == -1)
+            {
+                Pout<< "Internal" << endl;
+            }
+            else
+            if (epIndex < boundary.size())
+            {
+                Pout<< boundary[epIndex].name() << endl;
+            }
+            else
+            {
+                Pout<< " New patch: " << epIndex << endl;
+            }
+
+            Pout<< "Cell[0]: " << c0 << ": " << oldCells[0] << endl;
+
+            forAll(oldCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[0][faceI]];
+
+                Pout<< oldCells[0][faceI] << ": "
+                    << faces_[oldCells[0][faceI]]
+                    << " fE: " << fE
+                    << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
+                }
+            }
+        }
+
+        // Write out VTK files prior to change
+        if (debug > 3)
+        {
+            labelList cellHull(2, -1);
+
+            cellHull[0] = owner_[fIndex];
+            cellHull[1] = neighbour_[fIndex];
+
+            writeVTK
+            (
+                Foam::name(fIndex)
+              + "_Bisect_0",
+                cellHull
+            );
+        }
+    }
+
     // Find the isolated point on both boundary faces of cell[0]
     meshOps::findIsolatedPoint
     (
@@ -309,6 +656,64 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         )
     );
 
+    // Add the points to the map. Since this might require master mapping,
+    // first check to see if a slave is being bisected.
+    if (masterMap.addedPointList().size())
+    {
+        const List<objectMap>& pMap =
+        (
+            masterMap.addedPointList()
+        );
+
+        edge firstEdge
+        (
+            pMap[0].masterObjects()[0],
+            pMap[0].masterObjects()[1]
+        );
+
+        edge secondEdge
+        (
+            pMap[1].masterObjects()[0],
+            pMap[1].masterObjects()[1]
+        );
+
+        if (firstEdge == commonEdges[0] && secondEdge == commonEdges[1])
+        {
+            // Update in conventional order
+            map.addPoint(newPointIndex[0]);
+            map.addPoint(newPointIndex[1]);
+        }
+        else
+        if (firstEdge == commonEdges[1] && secondEdge == commonEdges[0])
+        {
+            // Update in reverse order
+            map.addPoint(newPointIndex[1]);
+            map.addPoint(newPointIndex[0]);
+        }
+        else
+        {
+            // We have a problem
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap "
+                "dynamicTopoFvMesh::bisectQuadFace\n"
+                "(\n"
+                "    const label fIndex,\n"
+                "    const changeMap& masterMap,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << "Coupled topo-change for slave failed."
+                << " firstEdge: " << firstEdge << nl
+                << " secondEdge: " << secondEdge << nl
+                << " commonEdges[0]: " << commonEdges[0] << nl
+                << " commonEdges[1]: " << commonEdges[1] << nl
+                << abort(FatalError);
+        }
+    }
+    else
     {
         map.addPoint(newPointIndex[0]);
         map.addPoint(newPointIndex[1]);
@@ -318,6 +723,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     // Currently invalid, but will be updated later.
     newCellIndex[0] = insertCell(newCells[0], lengthScale_[c0]);
 
+    // Add this cell to the map.
+    map.addCell(newCellIndex[0]);
+
     // Modify the two existing triangle boundary faces
 
     // Zeroth boundary face - Owner = c[0] & Neighbour [-1] (unchanged)
@@ -400,15 +808,15 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
     if (debug > 1)
     {
-        Info << "Modified face: " << fIndex
-             << ": " << faces_[fIndex] << endl;
+        Pout<< "Modified face: " << fIndex
+            << ": " << faces_[fIndex] << endl;
 
         if (debug > 2)
         {
-            Info << "Common edges: " << nl
-                 << commonEdgeIndex[0] << ": " << commonEdges[0] << nl
-                 << commonEdgeIndex[1] << ": " << commonEdges[1]
-                 << endl;
+            Pout<< "Common edges: " << nl
+                << commonEdgeIndex[0] << ": " << commonEdges[0] << nl
+                << commonEdgeIndex[1] << ": " << commonEdges[1]
+                << endl;
         }
     }
 
@@ -499,6 +907,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     // Add a faceEdges entry as well
     faceEdges_.append(tmpQFEdges);
 
+    // Add this face to the map.
+    map.addFace(newFaceIndex[0]);
+
     // Find the common edge between quad/quad faces...
     meshOps::findCommonEdge
     (
@@ -529,9 +940,6 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         oldCells[0]
     );
 
-    // remove2DSliver requires this face index for removal
-    map.addFace(newFaceIndex[0]);
-
     // Second boundary face; Owner = newCell[0] & Neighbour = [-1]
     tmpTriFace[0] = otherPointIndex[0];
     tmpTriFace[1] = newPointIndex[0];
@@ -551,6 +959,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     // Add a faceEdges entry as well
     faceEdges_.append(tmpTFEdges);
 
+    // Add this face to the map.
+    map.addFace(newFaceIndex[1]);
+
     meshOps::replaceLabel
     (
         -1,
@@ -577,6 +988,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     // Add a faceEdges entry as well
     faceEdges_.append(tmpTFEdges);
 
+    // Add this face to the map.
+    map.addFace(newFaceIndex[2]);
+
     meshOps::replaceLabel
     (
         -1,
@@ -602,6 +1016,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         )
     );
 
+    // Add this edge to the map.
+    map.addEdge(newEdgeIndex[1]);
+
     // Find the common edge between the quad/tri faces...
     meshOps::findCommonEdge
     (
@@ -641,6 +1058,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         )
     );
 
+    // Add this edge to the map.
+    map.addEdge(newEdgeIndex[2]);
+
     // Find the common edge between the quad/tri faces...
     meshOps::findCommonEdge
     (
@@ -685,12 +1105,12 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
-        // Add this face to the map.
-        map.addFace(newFaceIndex[3]);
-
         // Add a faceEdges entry as well
         faceEdges_.append(tmpQFEdges);
 
+        // Add this face to the map.
+        map.addFace(newFaceIndex[3]);
+
         // Correct edgeFaces for otherEdgeIndex[1]
         meshOps::replaceLabel
         (
@@ -723,6 +1143,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[0]);
+
         // Replace an edge on the bisected face
         meshOps::replaceLabel
         (
@@ -745,6 +1168,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[3]);
+
         tmpBiEdgeFaces[0] = c0BdyIndex[1];
         tmpBiEdgeFaces[1] = newFaceIndex[3];
 
@@ -758,6 +1184,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[4]);
+
         // Now that edges are defined, configure faceEdges
         // for all new faces
 
@@ -803,49 +1232,49 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
         if (debug > 2)
         {
-            Info << "Modified Cell[0]: "
-                 << c0 << ": " << oldCells[0] << endl;
+            Pout<< "Modified Cell[0]: "
+                << c0 << ": " << oldCells[0] << endl;
 
             forAll(oldCells[0], faceI)
             {
                 const labelList& fE = faceEdges_[oldCells[0][faceI]];
 
-                Info << oldCells[0][faceI]
-                     << ": " << faces_[oldCells[0][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< oldCells[0][faceI]
+                    << ": " << faces_[oldCells[0][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
 
-            Info << "New Cell[0]: " << newCellIndex[0]
-                 << ": " << newCells[0] << endl;
+            Pout<< "New Cell[0]: " << newCellIndex[0]
+                << ": " << newCells[0] << endl;
 
             forAll(newCells[0], faceI)
             {
                 const labelList& fE = faceEdges_[newCells[0][faceI]];
 
-                Info << newCells[0][faceI]
-                     << ": " << faces_[newCells[0][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< newCells[0][faceI]
+                    << ": " << faces_[newCells[0][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
         }
@@ -854,29 +1283,34 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     {
         oldCells[1] = cells_[c1];
 
+        // Add a new prism cell to the end of the list.
+        // Currently invalid, but will be updated later.
         newCellIndex[1] = insertCell(newCells[1], lengthScale_[c1]);
 
+        // Add this cell to the map.
+        map.addCell(newCellIndex[1]);
+
         if (debug > 2)
         {
-            Info << "Cell[1]: " << c1 << ": " << oldCells[1] << endl;
+            Pout<< "Cell[1]: " << c1 << ": " << oldCells[1] << endl;
 
             forAll(oldCells[1], faceI)
             {
                 const labelList& fE = faceEdges_[oldCells[1][faceI]];
 
-                Info << oldCells[1][faceI] << ": "
-                     << faces_[oldCells[1][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< oldCells[1][faceI] << ": "
+                    << faces_[oldCells[1][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
         }
@@ -966,6 +1400,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         // Add a faceEdges entry as well
         faceEdges_.append(tmpQFEdges);
 
+        // Add this face to the map.
+        map.addFace(newFaceIndex[3]);
+
         // Correct edgeFaces for otherEdgeIndex[1]
         meshOps::replaceLabel
         (
@@ -1041,10 +1478,10 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
         if (debug > 2)
         {
-            Info << "Common edges: " << nl
-                 << commonEdgeIndex[2] << ": " << commonEdges[2] << nl
-                 << commonEdgeIndex[3] << ": " << commonEdges[3]
-                 << endl;
+            Pout<< "Common edges: " << nl
+                << commonEdgeIndex[2] << ": " << commonEdges[2] << nl
+                << commonEdgeIndex[3] << ": " << commonEdges[3]
+                << endl;
         }
 
         meshOps::findIsolatedPoint
@@ -1116,7 +1553,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         // Add a faceEdges entry as well
         faceEdges_.append(tmpQFEdges);
 
-        // remove2DSliver requires this face index for removal
+        // Add this face to the map.
         map.addFace(newFaceIndex[4]);
 
         // Find the common edge between quad/quad faces...
@@ -1168,6 +1605,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         // Add a faceEdges entry as well
         faceEdges_.append(tmpTFEdges);
 
+        // Add this face to the map.
+        map.addFace(newFaceIndex[5]);
+
         meshOps::replaceLabel
         (
             -1,
@@ -1194,6 +1634,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         // Add a faceEdges entry as well
         faceEdges_.append(tmpTFEdges);
 
+        // Add this face to the map.
+        map.addFace(newFaceIndex[6]);
+
         meshOps::replaceLabel
         (
             -1,
@@ -1220,6 +1663,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[0]);
+
         // Replace an edge on the bisected face
         meshOps::replaceLabel
         (
@@ -1243,6 +1689,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[3]);
+
         tmpTriEdgeFaces[0] = c0BdyIndex[1];
         tmpTriEdgeFaces[1] = newFaceIndex[3];
         tmpTriEdgeFaces[2] = newFaceIndex[6];
@@ -1257,6 +1706,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[4]);
+
         // The edge bisecting the second boundary triangular face
         tmpTriEdgeFaces[0] = commonFaceIndex[2];
         tmpTriEdgeFaces[1] = newFaceIndex[4];
@@ -1272,6 +1724,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[5]);
+
         // Find the common edge between the quad/tri faces...
         meshOps::findCommonEdge
         (
@@ -1311,6 +1766,9 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             )
         );
 
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex[6]);
+
         // Find the common edge between the quad/tri faces...
         meshOps::findCommonEdge
         (
@@ -1413,95 +1871,95 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
         if (debug > 2)
         {
-            Info << nl << "Modified Cell[0]: "
-                 << c0 << ": " << oldCells[0] << endl;
+            Pout<< nl << "Modified Cell[0]: "
+                << c0 << ": " << oldCells[0] << endl;
 
             forAll(oldCells[0], faceI)
             {
                 const labelList& fE = faceEdges_[oldCells[0][faceI]];
 
-                Info << oldCells[0][faceI]
-                     << ": " << faces_[oldCells[0][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< oldCells[0][faceI]
+                    << ": " << faces_[oldCells[0][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
 
-            Info << "New Cell[0]: "
-                 << newCellIndex[0] << ": " << newCells[0] << endl;
+            Pout<< "New Cell[0]: "
+                << newCellIndex[0] << ": " << newCells[0] << endl;
 
             forAll(newCells[0], faceI)
             {
                 const labelList& fE = faceEdges_[newCells[0][faceI]];
 
-                Info << newCells[0][faceI] << ": "
-                     << faces_[newCells[0][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< newCells[0][faceI] << ": "
+                    << faces_[newCells[0][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
 
-            Info << nl << "Modified Cell[1]: "
-                 << c1 << ": " << oldCells[1] << endl;
+            Pout<< nl << "Modified Cell[1]: "
+                << c1 << ": " << oldCells[1] << endl;
 
             forAll(oldCells[1], faceI)
             {
                 const labelList& fE = faceEdges_[oldCells[1][faceI]];
 
-                Info << oldCells[1][faceI] << ": "
-                     << faces_[oldCells[1][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< oldCells[1][faceI] << ": "
+                    << faces_[oldCells[1][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
 
-            Info << "New Cell[1]: "
-                 << newCellIndex[1] << ": " << newCells[1] << endl;
+            Pout<< "New Cell[1]: "
+                << newCellIndex[1] << ": " << newCells[1] << endl;
 
             forAll(newCells[1], faceI)
             {
                 const labelList& fE = faceEdges_[newCells[1][faceI]];
 
-                Info << newCells[1][faceI] << ": "
-                     << faces_[newCells[1][faceI]]
-                     << " fE: " << fE
-                     << endl;
+                Pout<< newCells[1][faceI] << ": "
+                    << faces_[newCells[1][faceI]]
+                    << " fE: " << fE
+                    << endl;
 
                 forAll(fE, edgeI)
                 {
                     const labelList& eF = edgeFaces_[fE[edgeI]];
 
-                    Info << '\t' << fE[edgeI]
-                         << ": " << edges_[fE[edgeI]]
-                         << " eF: " << eF
-                         << endl;
+                    Pout<< '\t' << fE[edgeI]
+                        << ": " << edges_[fE[edgeI]]
+                        << " eF: " << eF
+                        << endl;
                 }
             }
         }
@@ -1534,6 +1992,217 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         edges_[commonEdgeIndex[1]].end() = newPointIndex[1];
     }
 
+    if (coupledModification_)
+    {
+        // Alias for convenience...
+        const changeMap& slaveMap = slaveMaps[0];
+
+        const label pI = slaveMap.patchIndex();
+
+        // Fetch the appropriate coupleMap
+        const coupleMap* cMapPtr = NULL;
+
+        if (localCouple && !procCouple)
+        {
+            cMapPtr = &(patchCoupling_[pI].map());
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            cMapPtr = &(recvMeshes_[pI].map());
+        }
+
+        // Alias for convenience
+        const coupleMap& cMap = *cMapPtr;
+
+        // Add the new points to the coupling map
+        const List<objectMap>& apList = slaveMap.addedPointList();
+
+        if (bisectingSlave)
+        {
+            // Update reverse pointMap
+            cMap.mapMaster
+            (
+                coupleMap::POINT,
+                newPointIndex[0],
+                apList[0].index()
+            );
+
+            cMap.mapMaster
+            (
+                coupleMap::POINT,
+                newPointIndex[1],
+                apList[1].index()
+            );
+
+            // Update pointMap
+            cMap.mapSlave
+            (
+                coupleMap::POINT,
+                apList[0].index(),
+                newPointIndex[0]
+            );
+
+            cMap.mapSlave
+            (
+                coupleMap::POINT,
+                apList[1].index(),
+                newPointIndex[1]
+            );
+        }
+        else
+        {
+            // Update pointMap
+            cMap.mapSlave
+            (
+                coupleMap::POINT,
+                newPointIndex[0],
+                apList[0].index()
+            );
+
+            cMap.mapSlave
+            (
+                coupleMap::POINT,
+                newPointIndex[1],
+                apList[1].index()
+            );
+
+            // Update reverse pointMap
+            cMap.mapMaster
+            (
+                coupleMap::POINT,
+                apList[0].index(),
+                newPointIndex[0]
+            );
+
+            cMap.mapMaster
+            (
+                coupleMap::POINT,
+                apList[1].index(),
+                newPointIndex[1]
+            );
+        }
+
+        // Create a master/slave entry for the new face on the patch.
+        FixedList<bool, 2> foundMatch(false);
+        FixedList<label, 2> checkFaces(-1);
+
+        // Fill in the faces to check for...
+        checkFaces[0] = fIndex;
+        checkFaces[1] = newFaceIndex[3];
+
+        const List<objectMap>& afList = slaveMap.addedFaceList();
+
+        forAll (checkFaces, indexI)
+        {
+            const face& mFace = faces_[checkFaces[indexI]];
+
+            label sFaceIndex = -1;
+
+            forAll(afList, sfI)
+            {
+                const face* facePtr = NULL;
+
+                if (localCouple && !procCouple)
+                {
+                    facePtr = &(faces_[afList[sfI].index()]);
+                }
+                else
+                if (procCouple && !localCouple)
+                {
+                    const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+                    facePtr = &(mesh.faces_[afList[sfI].index()]);
+                }
+
+                const face& tFace = *facePtr;
+                FixedList<bool, 4> cP(false);
+
+                forAll(mFace, pointI)
+                {
+                    const Map<label>& pointMap =
+                    (
+                        cMap.entityMap(coupleMap::POINT)
+                    );
+
+                    if (tFace.which(pointMap[mFace[pointI]]) > -1)
+                    {
+                        cP[pointI] = true;
+                    }
+                }
+
+                if (cP[0] && cP[1] && cP[2] && cP[3])
+                {
+                    sFaceIndex = afList[sfI].index();
+                    foundMatch[indexI] = true;
+                    break;
+                }
+            }
+
+            if (foundMatch[indexI])
+            {
+                if (bisectingSlave)
+                {
+                    cMap.mapMaster
+                    (
+                        coupleMap::FACE,
+                        checkFaces[indexI],
+                        sFaceIndex
+                    );
+
+                    cMap.mapSlave
+                    (
+                        coupleMap::FACE,
+                        sFaceIndex,
+                        checkFaces[indexI]
+                    );
+                }
+                else
+                {
+                    cMap.mapSlave
+                    (
+                        coupleMap::FACE,
+                        checkFaces[indexI],
+                        sFaceIndex
+                    );
+
+                    cMap.mapMaster
+                    (
+                        coupleMap::FACE,
+                        sFaceIndex,
+                        checkFaces[indexI]
+                    );
+                }
+            }
+            else
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap "
+                    "dynamicTopoFvMesh::bisectQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    const changeMap& masterMap,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Failed to build coupled maps." << nl
+                    << " masterFace: " << mFace << nl
+                    << " Added slave faces: " << afList << nl
+                    << abort(FatalError);
+            }
+        }
+
+        // Push operation into coupleMap
+        cMap.pushOperation
+        (
+            slaveMap.index(),
+            coupleMap::BISECTION
+        );
+    }
+
     // Write out VTK files after change
     if (debug > 3)
     {
@@ -1677,7 +2346,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     // Increment surface-counter
     if (c1 == -1)
     {
-        statistics_[5]++;
+        // Do not update stats for processor patches
+        if (!processorCoupledEntity(fIndex))
+        {
+            statistics_[5]++;
+        }
     }
 
     // Increment the number of modifications
@@ -1690,11 +2363,13 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     return map;
 }
 
+
 // Method for the bisection of an edge in 3D
 // - Returns a changeMap with a type specifying:
 //     1: Bisection was successful
 //    -1: Bisection failed since max number of topo-changes was reached.
 //    -2: Bisection failed since resulting quality would be unacceptable.
+//    -3: Bisection failed since edge was on a noRefinement patch.
 // - AddedPoints contain the index of the newly added point.
 const changeMap dynamicTopoFvMesh::bisectEdge
 (
@@ -1709,7 +2384,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     //      [3] Bisect all cells surrounding this edge
     //      [4] Create internal/external edges for each bisected face
     //      [5] Create internal faces for each bisected cell
-    //      Update faceEdges, edgeFaces and edgePoints information
+    //      Update faceEdges and edgeFaces information
 
     // For 2D meshes, perform face-bisection
     if (twoDMesh_)
@@ -1721,7 +2396,9 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     label tIndex = self();
 
     // Prepare the changeMaps
-    changeMap map, slaveMap;
+    changeMap map;
+    List<changeMap> slaveMaps;
+    bool bisectingSlave = false;
 
     if
     (
@@ -1736,9 +2413,18 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     }
 
     // Check if edgeRefinements are to be avoided on patch.
-    if (lengthEstimator().checkRefinementPatch(whichEdgePatch(eIndex)))
+    const labelList& eF = edgeFaces_[eIndex];
+
+    forAll(eF, fI)
     {
-        return map;
+        label fPatch = whichPatch(eF[fI]);
+
+        if (baseMesh_.lengthEstimator().checkRefinementPatch(fPatch))
+        {
+            map.type() = -3;
+
+            return map;
+        }
     }
 
     // Sanity check: Is the index legitimate?
@@ -1755,10 +2441,338 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             ")\n"
         )
             << " Invalid index: " << eIndex
-            << " nEdges: " << nEdges_
             << abort(FatalError);
     }
 
+    // If coupled modification is set, and this is a
+    // master edge, bisect its slaves as well.
+    bool localCouple = false, procCouple = false;
+
+    if (coupledModification_)
+    {
+        const edge& eCheck = edges_[eIndex];
+
+        const label edgeEnum = coupleMap::EDGE;
+
+        // Is this a locally coupled edge (either master or slave)?
+        if (locallyCoupledEntity(eIndex, true))
+        {
+            localCouple = true;
+            procCouple = false;
+        }
+        else
+        if (processorCoupledEntity(eIndex))
+        {
+            procCouple = true;
+            localCouple = false;
+        }
+
+        if (localCouple && !procCouple)
+        {
+            // Determine the slave index.
+            label sIndex = -1, pIndex = -1;
+
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                    if ((sIndex = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        break;
+                    }
+
+                    // The following bit happens only during the sliver
+                    // exudation process, since slave edges are
+                    // usually not added to the coupled edge-stack.
+                    if ((sIndex = cMap.findMaster(edgeEnum, eIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        // Notice that we are bisecting a slave edge first.
+                        bisectingSlave = true;
+
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::bisectEdge\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Edge: " << eIndex << ": " << edges_[eIndex] << nl
+                    << abort(FatalError);
+            }
+            else
+            {
+                // If we've found the slave, size up the list
+                meshOps::sizeUpList
+                (
+                    changeMap(),
+                    slaveMaps
+                );
+
+                // Save index and patch for posterity
+                slaveMaps[0].index() = sIndex;
+                slaveMaps[0].patchIndex() = pIndex;
+            }
+
+            if (debug > 1)
+            {
+                Pout<< nl << " >> Bisecting slave edge: " << sIndex
+                    << " for master edge: " << eIndex << endl;
+            }
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            // If this is a new entity, bail out for now.
+            // This will be handled at the next time-step.
+            if (eIndex >= nOldEdges_)
+            {
+                return map;
+            }
+
+            // Check slaves
+            forAll(procIndices_, pI)
+            {
+                // Fetch reference to subMeshes
+                const coupledInfo& sendMesh = sendMeshes_[pI];
+                const coupledInfo& recvMesh = recvMeshes_[pI];
+
+                const coupleMap& scMap = sendMesh.map();
+                const coupleMap& rcMap = recvMesh.map();
+
+                // If this edge was sent to a lower-ranked
+                // processor, skip it.
+                if (procIndices_[pI] < Pstream::myProcNo())
+                {
+                    if (scMap.reverseEntityMap(edgeEnum).found(eIndex))
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Edge: " << eIndex
+                                << "::" << eCheck
+                                << " was sent to proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+                }
+
+                label sIndex = -1;
+
+                if ((sIndex = rcMap.findSlave(edgeEnum, eIndex)) > -1)
+                {
+                    if (debug > 3)
+                    {
+                        Pout<< "Checking slave edge: " << sIndex
+                            << " on proc: " << procIndices_[pI]
+                            << " for master edge: " << eIndex
+                            << endl;
+                    }
+
+                    // Check if a lower-ranked processor is
+                    // handling this edge
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Edge: " << eIndex
+                                << " is handled by proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Save index and patch for posterity
+                    slaveMaps[curIndex].index() = sIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+                }
+            }
+        }
+        else
+        {
+            // Something's wrong with coupling maps
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::bisectEdge\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " localCouple: " << localCouple << nl
+                << " procCouple: " << procCouple << nl
+                << " Edge: " << eIndex << ": " << edges_[eIndex] << nl
+                << abort(FatalError);
+        }
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        // First check the master for bisection feasibility.
+        changeMap masterMap = bisectEdge(eIndex, true, forceOp);
+
+        // Turn it back on.
+        setCoupledModification();
+
+        // Master couldn't perform bisection
+        if (masterMap.type() <= 0)
+        {
+            return masterMap;
+        }
+
+        // Now check each of the slaves for bisection feasibility
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+
+            // If the edge is mapped onto itself, skip check
+            // (occurs for cyclic edges)
+            if ((sIndex == eIndex) && localCouple)
+            {
+                continue;
+            }
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Test the slave edge
+            if (localCouple)
+            {
+                slaveMap = bisectEdge(sIndex, true, forceOp);
+            }
+            else
+            if (procCouple)
+            {
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                if (debug > 3)
+                {
+                    Pout<< "Checking slave edge: " << sIndex
+                        << "::" << sMesh.edges_[sIndex]
+                        << " on proc: " << procIndices_[pI]
+                        << " for master edge: " << eIndex
+                        << endl;
+                }
+
+                slaveMap = sMesh.bisectEdge(sIndex, true, forceOp);
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            if (slaveMap.type() <= 0)
+            {
+                // Slave couldn't perform bisection.
+                map.type() = -2;
+
+                return map;
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
+        }
+
+        // Next bisect each slave edge..
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+
+            // If the edge is mapped onto itself, skip modification
+            // (occurs for cyclic edges)
+            if ((sIndex == eIndex) && localCouple)
+            {
+                continue;
+            }
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Bisect the slave edge
+            if (localCouple)
+            {
+                slaveMap = bisectEdge(sIndex, false, forceOp);
+            }
+            else
+            {
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                slaveMap = sMesh.bisectEdge(sIndex, false, forceOp);
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            // The final operation has to succeed.
+            if (slaveMap.type() <= 0)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::bisectEdge\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled topo-change for slave failed." << nl
+                    << " Edge: " << eIndex << ": " << edges_[eIndex] << nl
+                    << " Slave index: " << sIndex << nl
+                    << " Patch index: " << pI << nl
+                    << " Type: " << slaveMap.type() << nl
+                    << abort(FatalError);
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
+        }
+    }
+
     // Before we bisect this edge, check whether the operation will
     // yield an acceptable cell-quality.
     scalar minQ = 0.0;
@@ -1793,6 +2807,13 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     // Are we performing only checks?
     if (checkOnly)
     {
+        if (debug > 3 && isSubMesh_)
+        {
+            Pout<< "  Slave edge: " << eIndex
+                << " can be bisected."
+                << endl;
+        }
+
         map.type() = 1;
         return map;
     }
@@ -1800,22 +2821,26 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     // Update number of surface bisections, if necessary.
     if (whichEdgePatch(eIndex) > -1)
     {
-        statistics_[5]++;
+        // Do not update stats for processor patches
+        if (!processorCoupledEntity(eIndex))
+        {
+            statistics_[5]++;
+        }
     }
 
     // Hull variables
     face tmpTriFace(3);
+    edge origEdge(edges_[eIndex]);
     labelList tmpEdgeFaces(3,-1);
     labelList tmpIntEdgeFaces(4,-1);
-    labelList tmpEdgePoints(3,-1);
-    labelList tmpIntEdgePoints(4,-1);
     labelList tmpFaceEdges(3,-1);
 
-    // Make a copy of existing entities
-    const labelList vertexHull = edgePoints_[eIndex];
-    label m = vertexHull.size();
+    // Build vertexHull for this edge
+    labelList vertexHull;
+    buildVertexHull(eIndex, vertexHull);
 
     // Size up the hull lists
+    label m = vertexHull.size();
     labelList cellHull(m, -1);
     labelList faceHull(m, -1);
     labelList edgeHull(m, -1);
@@ -1832,7 +2857,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
         neighbour_,
         faceEdges_,
         edgeFaces_,
-        edgePoints_,
+        vertexHull,
         edgeHull,
         faceHull,
         cellHull,
@@ -1841,32 +2866,46 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
     if (debug > 1)
     {
-        Info << nl << nl
-             << "Edge: " << eIndex
-             << ": " << edges_[eIndex]
-             << " is to be bisected. " << endl;
+        Pout<< nl << nl
+            << "Edge: " << eIndex
+            << ": " << origEdge
+            << " is to be bisected. " << endl;
+
+        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichEdgePatch(eIndex);
 
-        Info << "Patch: ";
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
 
         if (epIndex == -1)
         {
-            Info << "Internal" << endl;
+            Pout<< "Internal" << endl;
+        }
+        else
+        if (epIndex < boundary.size())
+        {
+            Pout<< boundary[epIndex].name() << endl;
         }
         else
         {
-            Info << boundaryMesh()[epIndex].name() << endl;
+            Pout<< " New patch: " << epIndex << endl;
         }
 
         // Write out VTK files prior to change
+        //  - Using old-points for convenience in post-processing
         if (debug > 3)
         {
             writeVTK
             (
                 Foam::name(eIndex)
+              + '(' + Foam::name(origEdge[0])
+              + ',' + Foam::name(origEdge[1]) + ')'
               + "_Bisect_0",
-                cellHull
+                cellHull,
+                3, false, true
             );
         }
     }
@@ -1897,6 +2936,11 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     // This makes it convenient for coupled patch matching.
     label nePatch = -1;
 
+    if (locallyCoupledEntity(eIndex, true))
+    {
+        nePatch = locallyCoupledEdgePatch(eIndex);
+    }
+    else
     {
         nePatch = whichEdgePatch(eIndex);
     }
@@ -1908,8 +2952,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
         (
             nePatch,
             edge(newPointIndex,edges_[eIndex][1]),
-            labelList(faceHull.size(),-1),
-            vertexHull
+            labelList(faceHull.size(),-1)
         )
     );
 
@@ -1946,14 +2989,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             faces_[faceHull[indexI]]
         );
 
-        // Modify edgePoints for the edge
-        meshOps::replaceLabel
-        (
-            edges_[newEdgeIndex][1],
-            newPointIndex,
-            edgePoints_[ringEntities[0][indexI]]
-        );
-
         // Obtain circular indices
         label nextI = vertexHull.fcIndex(indexI);
         label prevI = vertexHull.rcIndex(indexI);
@@ -1966,7 +3001,11 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
             addedCellIndices[indexI] =
             (
-                insertCell(newCell, lengthScale_[cellHull[indexI]])
+                insertCell
+                (
+                    newCell,
+                    lengthScale_[cellHull[indexI]]
+                )
             );
 
             // Add this cell to the map.
@@ -2033,15 +3072,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 edgeFaces_[edgeHull[indexI]]
             );
 
-            // Insert the new point to edgePoints for the ring edge
-            meshOps::insertLabel
-            (
-                newPointIndex,
-                edges_[eIndex][0],
-                edges_[newEdgeIndex][1],
-                edgePoints_[edgeHull[indexI]]
-            );
-
             // Add this edge to faceEdges for the new interior face
             faceEdges_[addedIntFaceIndices[indexI]][0] = edgeHull[indexI];
 
@@ -2084,11 +3114,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 tmpEdgeFaces[1] = addedIntFaceIndices[indexI];
                 tmpEdgeFaces[2] = addedFaceIndices[indexI];
 
-                // Configure edgePoints
-                tmpEdgePoints[0] = edges_[eIndex][0];
-                tmpEdgePoints[1] = vertexHull[nextI];
-                tmpEdgePoints[2] = edges_[newEdgeIndex][1];
-
                 // Add an edge
                 addedEdgeIndices[indexI] =
                 (
@@ -2096,8 +3121,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     (
                         whichPatch(faceHull[indexI]),
                         edge(newPointIndex,vertexHull[indexI]),
-                        tmpEdgeFaces,
-                        tmpEdgePoints
+                        tmpEdgeFaces
                     )
                 );
 
@@ -2131,14 +3155,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     edgeFaces_[ringEntities[2][indexI]]
                 );
 
-                // Modify edgePoints for the edge connected to newEdge[1]
-                meshOps::replaceLabel
-                (
-                    edges_[eIndex][0],
-                    newPointIndex,
-                    edgePoints_[ringEntities[2][indexI]]
-                );
-
                 // Add the faceEdges entry
                 faceEdges_.append(tmpFaceEdges);
 
@@ -2178,12 +3194,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 tmpIntEdgeFaces[2] = addedFaceIndices[indexI];
                 tmpIntEdgeFaces[3] = addedIntFaceIndices[prevI];
 
-                // Configure edgePoints
-                tmpIntEdgePoints[0] = edges_[eIndex][0];
-                tmpIntEdgePoints[1] = vertexHull[nextI];
-                tmpIntEdgePoints[2] = edges_[newEdgeIndex][1];
-                tmpIntEdgePoints[3] = vertexHull[prevI];
-
                 // Add an internal edge
                 addedEdgeIndices[indexI] =
                 (
@@ -2191,8 +3201,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     (
                         -1,
                         edge(newPointIndex,vertexHull[indexI]),
-                        tmpIntEdgeFaces,
-                        tmpIntEdgePoints
+                        tmpIntEdgeFaces
                     )
                 );
 
@@ -2232,14 +3241,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     edgeFaces_[ringEntities[2][indexI]]
                 );
 
-                // Modify edgePoints for the edge connected to newEdge[1]
-                meshOps::replaceLabel
-                (
-                    edges_[eIndex][0],
-                    newPointIndex,
-                    edgePoints_[ringEntities[2][indexI]]
-                );
-
                 // Add the faceEdges entry
                 faceEdges_.append(tmpFaceEdges);
 
@@ -2282,12 +3283,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 tmpIntEdgeFaces[2] = addedFaceIndices[0];
                 tmpIntEdgeFaces[3] = addedIntFaceIndices[indexI];
 
-                // Configure edgePoints
-                tmpIntEdgePoints[0] = edges_[eIndex][0];
-                tmpIntEdgePoints[1] = vertexHull[1];
-                tmpIntEdgePoints[2] = edges_[newEdgeIndex][1];
-                tmpIntEdgePoints[3] = vertexHull[indexI];
-
                 // Add an internal edge
                 addedEdgeIndices[0] =
                 (
@@ -2295,8 +3290,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     (
                         -1,
                         edge(newPointIndex,vertexHull[0]),
-                        tmpIntEdgeFaces,
-                        tmpIntEdgePoints
+                        tmpIntEdgeFaces
                     )
                 );
 
@@ -2336,14 +3330,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     edgeFaces_[ringEntities[2][0]]
                 );
 
-                // Modify edgePoints for the edge connected to newEdge[1]
-                meshOps::replaceLabel
-                (
-                    edges_[eIndex][0],
-                    newPointIndex,
-                    edgePoints_[ringEntities[2][0]]
-                );
-
                 // Add the faceEdges entry
                 faceEdges_.append(tmpFaceEdges);
 
@@ -2387,11 +3373,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             tmpEdgeFaces[1] = addedIntFaceIndices[prevI];
             tmpEdgeFaces[2] = faceHull[indexI];
 
-            // Configure edgePoints
-            tmpEdgePoints[0] = edges_[newEdgeIndex][1];
-            tmpEdgePoints[1] = vertexHull[prevI];
-            tmpEdgePoints[2] = edges_[eIndex][0];
-
             // Add an edge
             addedEdgeIndices[indexI] =
             (
@@ -2399,8 +3380,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 (
                     whichPatch(faceHull[indexI]),
                     edge(newPointIndex,vertexHull[indexI]),
-                    tmpEdgeFaces,
-                    tmpEdgePoints
+                    tmpEdgeFaces
                 )
             );
 
@@ -2434,14 +3414,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 edgeFaces_[ringEntities[2][indexI]]
             );
 
-            // Modify edgePoints for the edge connected to newEdge[1]
-            meshOps::replaceLabel
-            (
-                edges_[eIndex][0],
-                newPointIndex,
-                edgePoints_[ringEntities[2][indexI]]
-            );
-
             // Add the faceEdges entry
             faceEdges_.append(tmpFaceEdges);
 
@@ -2514,25 +3486,484 @@ const changeMap dynamicTopoFvMesh::bisectEdge
         }
     }
 
+    // If modification is coupled, update mapping info.
+    if (coupledModification_)
+    {
+        // Build a list of boundary edges / faces for mapping
+        DynamicList<label> checkEdges(8), checkFaces(4);
+
+        const labelList& oeFaces = edgeFaces_[eIndex];
+        const labelList& neFaces = edgeFaces_[newEdgeIndex];
+
+        forAll(oeFaces, faceI)
+        {
+            FixedList<label, 2> check(-1);
+
+            check[0] = oeFaces[faceI];
+            check[1] = neFaces[faceI];
+
+            forAll(check, indexI)
+            {
+                label cPatch = whichPatch(check[indexI]);
+
+                if (localCouple && !procCouple)
+                {
+                    if (!locallyCoupledEntity(check[indexI], true, false, true))
+                    {
+                        continue;
+                    }
+
+                    // Check for cyclics
+                    if (boundaryMesh()[cPatch].type() == "cyclic")
+                    {
+                        // Check if this is a master face
+                        const coupleMap& cM = patchCoupling_[cPatch].map();
+                        const Map<label>& fM = cM.entityMap(coupleMap::FACE);
+
+                        // Only add master faces
+                        // (belonging to the first half)
+                        //  - Only check[0] will be present,
+                        //    so check for that alone
+                        if (!fM.found(check[0]))
+                        {
+                            continue;
+                        }
+                    }
+                }
+                else
+                if (procCouple && !localCouple)
+                {
+                    if (getNeighbourProcessor(cPatch) == -1)
+                    {
+                        continue;
+                    }
+                }
+
+                // Add face and its edges for checking
+                if (findIndex(checkFaces, check[indexI]) == -1)
+                {
+                    // Add this face
+                    checkFaces.append(check[indexI]);
+
+                    const labelList& fEdges = faceEdges_[check[indexI]];
+
+                    forAll(fEdges, edgeI)
+                    {
+                        if (findIndex(checkEdges, fEdges[edgeI]) == -1)
+                        {
+                            checkEdges.append(fEdges[edgeI]);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Output check entities
+        if (debug > 4)
+        {
+            writeVTK
+            (
+                "checkEdges_" + Foam::name(eIndex),
+                checkEdges, 1, false, true
+            );
+
+            writeVTK
+            (
+                "checkFaces_" + Foam::name(eIndex),
+                checkFaces, 2, false, true
+            );
+        }
+
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            const changeMap& slaveMap = slaveMaps[slaveI];
+
+            const label pI = slaveMap.patchIndex();
+
+            // Fetch the appropriate coupleMap / mesh
+            const coupleMap* cMapPtr = NULL;
+            const dynamicTopoFvMesh* sMeshPtr = NULL;
+
+            if (localCouple && !procCouple)
+            {
+                cMapPtr = &(patchCoupling_[pI].map());
+                sMeshPtr = this;
+            }
+            else
+            if (procCouple && !localCouple)
+            {
+                cMapPtr = &(recvMeshes_[pI].map());
+                sMeshPtr = &(recvMeshes_[pI].subMesh());
+            }
+
+            // Alias for convenience
+            const coupleMap& cMap = *cMapPtr;
+            const dynamicTopoFvMesh& sMesh = *sMeshPtr;
+
+            // Add the new points to the coupling map
+            const List<objectMap>& apList = slaveMap.addedPointList();
+
+            // Fetch the slave point
+            label slavePoint = -1;
+
+            if ((slaveMap.index() == eIndex) && localCouple)
+            {
+                // Cyclic edge at axis
+                slavePoint = newPointIndex;
+            }
+            else
+            {
+                slavePoint = apList[0].index();
+            }
+
+            // Map points
+            if (bisectingSlave)
+            {
+                // Update reverse pointMap
+                cMap.mapMaster
+                (
+                    coupleMap::POINT,
+                    newPointIndex,
+                    slavePoint
+                );
+
+                // Update pointMap
+                cMap.mapSlave
+                (
+                    coupleMap::POINT,
+                    slavePoint,
+                    newPointIndex
+                );
+            }
+            else
+            {
+                // Update pointMap
+                cMap.mapSlave
+                (
+                    coupleMap::POINT,
+                    newPointIndex,
+                    slavePoint
+                );
+
+                // Update reverse pointMap
+                cMap.mapMaster
+                (
+                    coupleMap::POINT,
+                    slavePoint,
+                    newPointIndex
+                );
+            }
+
+            if (debug > 2)
+            {
+                Pout<< " Adding point: " << slavePoint
+                    << " for point: " << newPointIndex
+                    << endl;
+            }
+
+            // Obtain point maps
+            const Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+
+            // Update face mapping
+            const label faceEnum = coupleMap::FACE;
+
+            // Obtain references
+            Map<label>& faceMap = cMap.entityMap(faceEnum);
+            Map<label>& rFaceMap = cMap.reverseEntityMap(faceEnum);
+
+            forAll(checkFaces, faceI)
+            {
+                label mfIndex = checkFaces[faceI];
+
+                const face& mF = faces_[mfIndex];
+
+                label mfPatch = whichPatch(mfIndex);
+
+                // Check for processor match
+                label neiProc = getNeighbourProcessor(mfPatch);
+
+                if (procCouple && !localCouple)
+                {
+                    if (neiProc != procIndices_[pI])
+                    {
+                        continue;
+                    }
+                }
+
+                triFace cF
+                (
+                    pointMap.found(mF[0]) ? pointMap[mF[0]] : -1,
+                    pointMap.found(mF[1]) ? pointMap[mF[1]] : -1,
+                    pointMap.found(mF[2]) ? pointMap[mF[2]] : -1
+                );
+
+                // Skip mapping if all points were not found
+                if (cF[0] == -1 || cF[1] == -1 || cF[2] == -1)
+                {
+                    continue;
+                }
+
+                bool matchedFace = false;
+
+                // Fetch edges connected to the slave point
+                const labelList& spEdges = sMesh.pointEdges_[slavePoint];
+
+                forAll(spEdges, edgeI)
+                {
+                    label seIndex = spEdges[edgeI];
+
+                    if (sMesh.whichEdgePatch(seIndex) == -1)
+                    {
+                        continue;
+                    }
+
+                    const labelList& seFaces = sMesh.edgeFaces_[seIndex];
+
+                    forAll(seFaces, faceI)
+                    {
+                        label sfIndex = seFaces[faceI];
+
+                        if (sMesh.whichPatch(sfIndex) == -1)
+                        {
+                            continue;
+                        }
+
+                        const face& sF = sMesh.faces_[sfIndex];
+
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(sF[0], sF[1], sF[2]), cF
+                            )
+                        )
+                        {
+                            if (debug > 2)
+                            {
+                                word pN(boundaryMesh()[mfPatch].name());
+
+                                Pout<< " Found face: " << sfIndex
+                                    << " :: " << sF
+                                    << " with mfIndex: " << mfIndex
+                                    << " :: " << mF
+                                    << " Patch: " << pN
+                                    << endl;
+                            }
+
+                            if (rFaceMap.found(sfIndex))
+                            {
+                                rFaceMap[sfIndex] = mfIndex;
+                            }
+                            else
+                            {
+                                rFaceMap.insert(sfIndex, mfIndex);
+                            }
+
+                            if (faceMap.found(mfIndex))
+                            {
+                                faceMap[mfIndex] = sfIndex;
+                            }
+                            else
+                            {
+                                faceMap.insert(mfIndex, sfIndex);
+                            }
+
+                            matchedFace = true;
+
+                            break;
+                        }
+                    }
+
+                    if (matchedFace)
+                    {
+                        break;
+                    }
+                }
+
+                if (!matchedFace)
+                {
+                    sMesh.writeVTK
+                    (
+                        "failedFacePoints_"
+                      + Foam::name(mfIndex),
+                        cF, 0, false, true
+                    );
+
+                    writeVTK
+                    (
+                        "checkFaces_" + Foam::name(eIndex),
+                        checkFaces, 2, false, true
+                    );
+
+                    Pout<< " Failed to match face: "
+                        << mfIndex << " :: " << mF
+                        << " masterPatch: " << mfPatch
+                        << " using comparison face: " << cF
+                        << abort(FatalError);
+                }
+            }
+
+            // Update edge mapping
+            const label edgeEnum = coupleMap::EDGE;
+
+            // Obtain references
+            Map<label>& edgeMap = cMap.entityMap(edgeEnum);
+            Map<label>& rEdgeMap = cMap.reverseEntityMap(edgeEnum);
+
+            forAll(checkEdges, edgeI)
+            {
+                label meIndex = checkEdges[edgeI];
+
+                const edge& mE = edges_[meIndex];
+
+                label mePatch = whichPatch(meIndex);
+                label neiProc = getNeighbourProcessor(mePatch);
+
+                edge cE
+                (
+                    pointMap.found(mE[0]) ? pointMap[mE[0]] : -1,
+                    pointMap.found(mE[1]) ? pointMap[mE[1]] : -1
+                );
+
+                // Skip mapping if all points were not found
+                if (cE[0] == -1 || cE[1] == -1)
+                {
+                    continue;
+                }
+
+                bool matchedEdge = false;
+
+                // Fetch edges connected to the slave point
+                const labelList& spEdges = sMesh.pointEdges_[cE[0]];
+
+                forAll(spEdges, edgeI)
+                {
+                    label seIndex = spEdges[edgeI];
+
+                    const edge& sE = sMesh.edges_[seIndex];
+
+                    if (sE == cE)
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found edge: " << seIndex
+                                << " :: " << sE
+                                << " with meIndex: " << meIndex
+                                << " :: " << mE
+                                << endl;
+                        }
+
+                        // Update reverse map
+                        if (rEdgeMap.found(seIndex))
+                        {
+                            rEdgeMap[seIndex] = meIndex;
+                        }
+                        else
+                        {
+                            rEdgeMap.insert(seIndex, meIndex);
+                        }
+
+                        // Update map
+                        if (edgeMap.found(meIndex))
+                        {
+                            edgeMap[meIndex] = seIndex;
+                        }
+                        else
+                        {
+                            edgeMap.insert(meIndex, seIndex);
+                        }
+
+                        matchedEdge = true;
+
+                        break;
+                    }
+                }
+
+                if (!matchedEdge)
+                {
+                    if (procCouple && !localCouple)
+                    {
+                        // Rare occassion where both points
+                        // of the edge lie on processor, but
+                        // not the edge itself.
+                        if (neiProc != procIndices_[pI])
+                        {
+                            if (debug > 2)
+                            {
+                                Pout<< " Edge: " << meIndex
+                                    << " :: " << mE
+                                    << " with comparison: " << cE
+                                    << " has points on processor: " << neiProc
+                                    << " but no edge. Marking as matched."
+                                    << endl;
+                            }
+
+                            matchedEdge = true;
+                        }
+                    }
+                }
+
+                if (!matchedEdge)
+                {
+                    sMesh.writeVTK
+                    (
+                        "failedEdge_"
+                      + Foam::name(meIndex),
+                        cE, 0, false, true
+                    );
+
+                    writeVTK
+                    (
+                        "checkEdges_" + Foam::name(eIndex),
+                        checkEdges, 1, false, true
+                    );
+
+                    Pout<< " Failed to match edge: "
+                        << meIndex << " :: " << mE
+                        << " using comparison edge: " << cE
+                        << abort(FatalError);
+                }
+            }
+
+            // Push operation into coupleMap
+            if (procCouple && !localCouple)
+            {
+                cMap.pushOperation
+                (
+                    slaveMap.index(),
+                    coupleMap::BISECTION
+                );
+            }
+        }
+    }
+
     if (debug > 2)
     {
         label bPatch = whichEdgePatch(eIndex);
 
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
         if (bPatch == -1)
         {
-            Info << "Patch: Internal" << endl;
+            Pout<< "Patch: Internal" << nl;
+        }
+        else
+        if (bPatch < boundary.size())
+        {
+            Pout<< "Patch: " << boundary[bPatch].name() << nl;
         }
         else
         {
-            Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+            Pout<< " New patch: " << bPatch << endl;
         }
 
-        Info << "EdgePoints: " << vertexHull << endl;
-        Info << "Edges: " << edgeHull << endl;
-        Info << "Faces: " << faceHull << endl;
-        Info << "Cells: " << cellHull << endl;
+        Pout<< "vertexHull: " << vertexHull << nl
+            << "Edges: " << edgeHull << nl
+            << "Faces: " << faceHull << nl
+            << "Cells: " << cellHull << nl;
 
-        Info << "Modified cells: " << endl;
+        Pout<< "Modified cells: " << nl;
 
         forAll(cellHull, cellI)
         {
@@ -2541,12 +3972,12 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 continue;
             }
 
-            Info << cellHull[cellI] << ":: "
-                 << cells_[cellHull[cellI]]
-                 << endl;
+            Pout<< cellHull[cellI] << ":: "
+                << cells_[cellHull[cellI]]
+                << nl;
         }
 
-        Info << "Added cells: " << endl;
+        Pout<< nl << "Added cells: " << nl;
 
         forAll(addedCellIndices, cellI)
         {
@@ -2555,34 +3986,34 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 continue;
             }
 
-            Info << addedCellIndices[cellI] << ":: "
-                 << cells_[addedCellIndices[cellI]] << nl
-                 << "lengthScale: " << lengthScale_[addedCellIndices[cellI]]
-                 << endl;
+            Pout<< addedCellIndices[cellI] << ":: "
+                << cells_[addedCellIndices[cellI]] << nl
+                << "lengthScale: " << lengthScale_[addedCellIndices[cellI]]
+                << nl;
         }
 
-        Info << "Modified faces: " << endl;
+        Pout<< nl << "Modified faces: " << nl;
 
         forAll(faceHull, faceI)
         {
-            Info << faceHull[faceI] << ":: "
-                 << faces_[faceHull[faceI]] << ": "
-                 << owner_[faceHull[faceI]] << ": "
-                 << neighbour_[faceHull[faceI]] << " "
-                 << "faceEdges:: " << faceEdges_[faceHull[faceI]]
-                 << endl;
+            Pout<< faceHull[faceI] << ":: "
+                << faces_[faceHull[faceI]] << ": "
+                << owner_[faceHull[faceI]] << ": "
+                << neighbour_[faceHull[faceI]] << " "
+                << "faceEdges:: " << faceEdges_[faceHull[faceI]]
+                << nl;
         }
 
-        Info << "Added faces: " << endl;
+        Pout<< nl << "Added faces: " << nl;
 
         forAll(addedFaceIndices, faceI)
         {
-            Info << addedFaceIndices[faceI] << ":: "
-                 << faces_[addedFaceIndices[faceI]] << ": "
-                 << owner_[addedFaceIndices[faceI]] << ": "
-                 << neighbour_[addedFaceIndices[faceI]] << " "
-                 << "faceEdges:: " << faceEdges_[addedFaceIndices[faceI]]
-                 << endl;
+            Pout<< addedFaceIndices[faceI] << ":: "
+                << faces_[addedFaceIndices[faceI]] << ": "
+                << owner_[addedFaceIndices[faceI]] << ": "
+                << neighbour_[addedFaceIndices[faceI]] << " "
+                << "faceEdges:: " << faceEdges_[addedFaceIndices[faceI]]
+                << nl;
         }
 
         forAll(addedIntFaceIndices, faceI)
@@ -2592,34 +4023,34 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 continue;
             }
 
-            Info << addedIntFaceIndices[faceI] << ":: "
-                 << faces_[addedIntFaceIndices[faceI]] << ": "
-                 << owner_[addedIntFaceIndices[faceI]] << ": "
-                 << neighbour_[addedIntFaceIndices[faceI]] << " "
-                 << "faceEdges:: "
-                 << faceEdges_[addedIntFaceIndices[faceI]]
-                 << endl;
+            Pout<< addedIntFaceIndices[faceI] << ":: "
+                << faces_[addedIntFaceIndices[faceI]] << ": "
+                << owner_[addedIntFaceIndices[faceI]] << ": "
+                << neighbour_[addedIntFaceIndices[faceI]] << " "
+                << "faceEdges:: " << faceEdges_[addedIntFaceIndices[faceI]]
+                << nl;
         }
 
-        Info << "New edge:: " << newEdgeIndex
-             << ": " << edges_[newEdgeIndex] << nl
-             << " edgeFaces:: " << edgeFaces_[newEdgeIndex] << nl
-             << " edgePoints:: " << edgePoints_[newEdgeIndex]
-             << endl;
+        Pout<< nl << "New edge:: " << newEdgeIndex
+            << ": " << edges_[newEdgeIndex] << nl
+            << " edgeFaces:: " << edgeFaces_[newEdgeIndex]
+            << nl;
 
-        Info << "Added edges: " << endl;
+        Pout<< nl << "Added edges: " << nl;
 
         forAll(addedEdgeIndices, edgeI)
         {
-            Info << addedEdgeIndices[edgeI]
-                 << ":: " << edges_[addedEdgeIndices[edgeI]] << nl
-                 << " edgeFaces:: " << edgeFaces_[addedEdgeIndices[edgeI]] << nl
-                 << " edgePoints:: " << edgePoints_[addedEdgeIndices[edgeI]]
-                 << endl;
+            Pout<< addedEdgeIndices[edgeI]
+                << ":: " << edges_[addedEdgeIndices[edgeI]] << nl
+                << " edgeFaces:: " << edgeFaces_[addedEdgeIndices[edgeI]]
+                << nl;
         }
 
-        Info << "New Point:: " << newPointIndex << endl;
-        Info << "pointEdges:: " << pointEdges_[newPointIndex] << endl;
+        Pout<< "New Point:: " << newPointIndex << nl
+            << "pointEdges:: " << pointEdges_[newPointIndex] << nl;
+
+        // Flush buffer
+        Pout<< endl;
 
         // Write out VTK files after change
         if (debug > 3)
@@ -2639,11 +4070,16 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 newHull[i] = addedCellIndices[i - start];
             }
 
+            // Write out VTK files after change
+            //  - Using old-points for convenience in post-processing
             writeVTK
             (
                 Foam::name(eIndex)
+              + '(' + Foam::name(origEdge[0])
+              + ',' + Foam::name(origEdge[1]) + ')'
               + "_Bisect_1",
-                newHull
+                newHull,
+                3, false, true
             );
         }
     }
@@ -2664,6 +4100,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     return map;
 }
 
+
 // Method for the trisection of a face in 3D
 // - Returns a changeMap with a type specifying:
 //     1: Trisection was successful
@@ -2684,13 +4121,14 @@ const changeMap dynamicTopoFvMesh::trisectFace
     //      [4] Create one internal edge for each trisected cell.
     //      [5] Create three edges for the trisected face.
     //      [6] Create three internal faces for each trisected cell.
-    //      Update faceEdges, edgeFaces and edgePoints information.
+    //      Update faceEdges and edgeFaces information.
 
     // Figure out which thread this is...
-    label tIndex = self();
+    label tIndex = self(), pIndex = -1;
 
     // Prepare the changeMaps
     changeMap map, slaveMap;
+    bool trisectingSlave = false;
 
     if
     (
@@ -2720,6 +4158,130 @@ const changeMap dynamicTopoFvMesh::trisectFace
             << abort(FatalError);
     }
 
+    if (coupledModification_)
+    {
+        // Is this a locally coupled face (either master or slave)?
+        if (locallyCoupledEntity(fIndex, true))
+        {
+            label sIndex = -1;
+
+            // Loop through master/slave maps
+            // and determine the coupled edge index.
+            forAll(patchCoupling_, patchI)
+            {
+                if (!patchCoupling_(patchI))
+                {
+                    continue;
+                }
+
+                const label faceEnum  = coupleMap::FACE;
+                const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                if ((sIndex = cMap.findSlave(faceEnum, fIndex)) > -1)
+                {
+                    // Keep this index for master/slave mapping.
+                    pIndex = patchI;
+
+                    break;
+                }
+
+                // The following bit happens only during the sliver
+                // exudation process.
+                if ((sIndex = cMap.findMaster(faceEnum, fIndex)) > -1)
+                {
+                    // Keep this index for master/slave mapping.
+                    pIndex = patchI;
+
+                    // Notice that we are trisecting a slave edge.
+                    trisectingSlave = true;
+
+                    break;
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "const changeMap dynamicTopoFvMesh::trisectFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Face: " << fIndex << nl
+                    << abort(FatalError);
+            }
+
+            if (debug > 1)
+            {
+                Pout<< nl << "Trisecting slave face: " << sIndex
+                    << " for master face: " << fIndex << endl;
+            }
+
+            // Temporarily turn off coupledModification.
+            unsetCoupledModification();
+
+            // First check the slave for trisection feasibility.
+            slaveMap = trisectFace(sIndex, true, forceOp);
+
+            if (slaveMap.type() == 1)
+            {
+                // Can the master be trisected as well?
+                changeMap masterMap = trisectFace(fIndex, true, forceOp);
+
+                // Master couldn't perform trisection
+                if (masterMap.type() != 1)
+                {
+                    setCoupledModification();
+
+                    return masterMap;
+                }
+
+                // Trisect the slave face
+                slaveMap = trisectFace(sIndex, false, forceOp);
+
+                // The final operation has to succeed.
+                if (slaveMap.type() <= 0)
+                {
+                    FatalErrorIn
+                    (
+                        "const changeMap dynamicTopoFvMesh::trisectFace\n"
+                        "(\n"
+                        "    const label fIndex,\n"
+                        "    bool checkOnly,\n"
+                        "    bool forceOp\n"
+                        ")\n"
+                    )
+                        << "Coupled topo-change for slave failed." << nl
+                        << " Type: " << slaveMap.type()
+                        << abort(FatalError);
+                }
+            }
+            else
+            {
+                // Slave couldn't perform trisection.
+                setCoupledModification();
+
+                map.type() = -2;
+
+                return map;
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+        }
+        else
+        if (processorCoupledEntity(fIndex))
+        {
+            // Trisect face on the patchSubMesh.
+
+        }
+    }
+
     // Before we trisect this face, check whether the operation will
     // yield an acceptable cell-quality.
     scalar minQ = 0.0;
@@ -2765,8 +4327,8 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
     // Hull variables
     face tmpTriFace(3);
-    labelList newTriEdgeFaces(3), newTriEdgePoints(3);
-    labelList newQuadEdgeFaces(4), newQuadEdgePoints(4);
+    labelList newTriEdgeFaces(3);
+    labelList newQuadEdgeFaces(4);
 
     FixedList<label,2> apexPoint(-1);
     FixedList<face, 3> checkFace(face(3));
@@ -2787,10 +4349,10 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
     if (debug > 1)
     {
-        Info << nl << nl
-             << "Face: " << fIndex
-             << ": " << faces_[fIndex]
-             << " is to be trisected. " << endl;
+        Pout<< nl << nl
+            << "Face: " << fIndex
+            << ": " << faces_[fIndex]
+            << " is to be trisected. " << endl;
 
         // Write out VTK files prior to change
         if (debug > 3)
@@ -2924,11 +4486,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
     newTriEdgeFaces[1] = newFaceIndex[1];
     newTriEdgeFaces[2] = newFaceIndex[2];
 
-    // Add an entry for edgePoints as well
-    newTriEdgePoints[0] = faces_[fIndex][0];
-    newTriEdgePoints[1] = faces_[fIndex][1];
-    newTriEdgePoints[2] = faces_[fIndex][2];
-
     // Add a new internal edge to the mesh
     newEdgeIndex[0] =
     (
@@ -2940,8 +4497,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                newPointIndex,
                apexPoint[0]
             ),
-            newTriEdgeFaces,
-            newTriEdgePoints
+            newTriEdgeFaces
         )
     );
 
@@ -3104,15 +4660,11 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newTetCell[1][nF[1]++] = newFaceIndex[4];
         newTetCell[2][nF[2]++] = newFaceIndex[5];
 
-        // Configure edgeFaces and edgePoints for three new boundary edges.
+        // Configure edgeFaces for three new boundary edges.
         newTriEdgeFaces[0] = newFaceIndex[4];
         newTriEdgeFaces[1] = newFaceIndex[0];
         newTriEdgeFaces[2] = newFaceIndex[3];
 
-        newTriEdgePoints[0] = faces_[fIndex][1];
-        newTriEdgePoints[1] = apexPoint[0];
-        newTriEdgePoints[2] = faces_[fIndex][2];
-
         newEdgeIndex[1] =
         (
             insertEdge
@@ -3123,8 +4675,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][0]
                 ),
-                newTriEdgeFaces,
-                newTriEdgePoints
+                newTriEdgeFaces
             )
         );
 
@@ -3132,10 +4683,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newTriEdgeFaces[1] = newFaceIndex[1];
         newTriEdgeFaces[2] = newFaceIndex[4];
 
-        newTriEdgePoints[0] = faces_[fIndex][2];
-        newTriEdgePoints[1] = apexPoint[0];
-        newTriEdgePoints[2] = faces_[fIndex][0];
-
         newEdgeIndex[2] =
         (
             insertEdge
@@ -3146,8 +4693,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][1]
                 ),
-                newTriEdgeFaces,
-                newTriEdgePoints
+                newTriEdgeFaces
             )
         );
 
@@ -3155,10 +4701,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newTriEdgeFaces[1] = newFaceIndex[2];
         newTriEdgeFaces[2] = newFaceIndex[5];
 
-        newTriEdgePoints[0] = faces_[fIndex][0];
-        newTriEdgePoints[1] = apexPoint[0];
-        newTriEdgePoints[2] = faces_[fIndex][1];
-
         newEdgeIndex[3] =
         (
             insertEdge
@@ -3169,8 +4711,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][2]
                 ),
-                newTriEdgeFaces,
-                newTriEdgePoints
+                newTriEdgeFaces
             )
         );
 
@@ -3198,7 +4739,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
         check[5][0] = faces_[fIndex][1]; check[5][1] = faces_[fIndex][2];
 
         // Build a list of cellEdges
-        labelHashSet cellEdges;
+        DynamicList<label> cellEdges(6);
 
         forAll(cells_[owner_[fIndex]], faceI)
         {
@@ -3209,116 +4750,72 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
             forAll(fEdges, edgeI)
             {
-                if (!cellEdges.found(fEdges[edgeI]))
+                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
                 {
-                    cellEdges.insert(fEdges[edgeI]);
+                    cellEdges.append(fEdges[edgeI]);
                 }
             }
         }
 
         // Loop through cellEdges, and perform appropriate actions.
-        forAllIter(labelHashSet, cellEdges, eIter)
+        forAll(cellEdges, edgeI)
         {
-            const edge& edgeToCheck = edges_[eIter.key()];
+            const label ceIndex = cellEdges[edgeI];
+            const edge& edgeToCheck = edges_[ceIndex];
 
             // Check against the specified edges.
             if (edgeToCheck == check[0])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][1],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[eIter.key()]);
-                newFaceEdges[0][nE[0]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[ceIndex]);
+                newFaceEdges[0][nE[0]++] = ceIndex;
             }
 
             if (edgeToCheck == check[1])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[eIter.key()]);
-                newFaceEdges[1][nE[1]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[ceIndex]);
+                newFaceEdges[1][nE[1]++] = ceIndex;
             }
 
             if (edgeToCheck == check[2])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][1],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[eIter.key()]);
-                newFaceEdges[2][nE[2]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[ceIndex]);
+                newFaceEdges[2][nE[2]++] = ceIndex;
             }
 
             if (edgeToCheck == check[3])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][1],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[3],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[3][nE[3]++] = eIter.key();
+                newFaceEdges[3][nE[3]++] = ceIndex;
             }
 
             if (edgeToCheck == check[4])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][2],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[4],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[4][nE[4]++] = eIter.key();
+                newFaceEdges[4][nE[4]++] = ceIndex;
             }
 
             if (edgeToCheck == check[5])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][0],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[5],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[5][nE[5]++] = eIter.key();
+                newFaceEdges[5][nE[5]++] = ceIndex;
             }
         }
 
@@ -3330,6 +4827,322 @@ const changeMap dynamicTopoFvMesh::trisectFace
             // Add faces to the map.
             map.addFace(newFaceIndex[i]);
         }
+
+        // If modification is coupled, generate mapping info.
+        if (coupledModification_)
+        {
+            // Create a master/slave entry for the new edges/faces on the patch.
+            if (locallyCoupledEntity(fIndex, true))
+            {
+                if (patchCoupling_(pIndex))
+                {
+                    // Add the new point to the coupling map
+                    const coupleMap& cMap = patchCoupling_[pIndex].map();
+
+                    if (trisectingSlave)
+                    {
+                        cMap.mapMaster
+                        (
+                            coupleMap::POINT,
+                            newPointIndex,
+                            slaveMap.addedPointList()[0].index()
+                        );
+
+                        cMap.mapSlave
+                        (
+                            coupleMap::POINT,
+                            slaveMap.addedPointList()[0].index(),
+                            newPointIndex
+                        );
+                    }
+                    else
+                    {
+                        cMap.mapSlave
+                        (
+                            coupleMap::POINT,
+                            newPointIndex,
+                            slaveMap.addedPointList()[0].index()
+                        );
+
+                        cMap.mapMaster
+                        (
+                            coupleMap::POINT,
+                            slaveMap.addedPointList()[0].index(),
+                            newPointIndex
+                        );
+                    }
+                }
+
+                const List<objectMap>& ameList = map.addedEdgeList();
+                const List<objectMap>& aseList = slaveMap.addedEdgeList();
+
+                // Compare with all check entries.
+                forAll(ameList, meI)
+                {
+                    label epIndex = whichEdgePatch(ameList[meI].index());
+
+                    if (epIndex != pIndex && !trisectingSlave)
+                    {
+                        continue;
+                    }
+
+                    if (patchCoupling_(pIndex))
+                    {
+                        const coupleMap& cM = patchCoupling_[pIndex].map();
+
+                        if (trisectingSlave && epIndex != cM.slaveIndex())
+                        {
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    const coupleMap& cMap = patchCoupling_[pIndex].map();
+
+                    // Configure an edge for comparison.
+                    edge cE(-1, -1);
+
+                    const edge& mE = edges_[ameList[meI].index()];
+
+                    if (trisectingSlave)
+                    {
+                        cE[0] = cMap.reverseEntityMap(coupleMap::POINT)[mE[0]];
+                        cE[1] = cMap.reverseEntityMap(coupleMap::POINT)[mE[1]];
+                    }
+                    else
+                    {
+                        cE[0] = cMap.entityMap(coupleMap::POINT)[mE[0]];
+                        cE[1] = cMap.entityMap(coupleMap::POINT)[mE[1]];
+                    }
+
+                    bool matched = false;
+
+                    forAll(aseList, seI)
+                    {
+                        const edge& sE = edges_[aseList[seI].index()];
+
+                        if (cE == sE)
+                        {
+                            if (trisectingSlave)
+                            {
+                                cMap.mapMaster
+                                (
+                                    coupleMap::EDGE,
+                                    ameList[meI].index(),
+                                    aseList[seI].index()
+                                );
+
+                                cMap.mapSlave
+                                (
+                                    coupleMap::EDGE,
+                                    aseList[seI].index(),
+                                    ameList[meI].index()
+                                );
+                            }
+                            else
+                            {
+                                cMap.mapSlave
+                                (
+                                    coupleMap::EDGE,
+                                    ameList[meI].index(),
+                                    aseList[seI].index()
+                                );
+
+                                cMap.mapMaster
+                                (
+                                    coupleMap::EDGE,
+                                    aseList[seI].index(),
+                                    ameList[meI].index()
+                                );
+                            }
+
+                            matched = true;
+
+                            break;
+                        }
+                    }
+
+                    if (!matched)
+                    {
+                        Pout<< "masterEdges: " << nl
+                            << ameList << endl;
+
+                        Pout<< "slaveEdges: " << nl
+                            << aseList << endl;
+
+                        forAll(ameList, meI)
+                        {
+                            Pout<< ameList[meI].index() << ": "
+                                << edges_[ameList[meI].index()]
+                                << endl;
+                        }
+
+                        forAll(aseList, seI)
+                        {
+                            Pout<< aseList[seI].index() << ": "
+                                << edges_[aseList[seI].index()]
+                                << endl;
+                        }
+
+                        FatalErrorIn
+                        (
+                            "const changeMap dynamicTopoFvMesh::trisectFace\n"
+                            "(\n"
+                            "    const label fIndex,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Failed to build coupled edge maps."
+                            << abort(FatalError);
+                    }
+                }
+
+                // Add a mapping entry for three new faces as well.
+                face cF(3);
+
+                const List<objectMap>& amfList = map.addedFaceList();
+                const List<objectMap>& asfList = slaveMap.addedFaceList();
+
+                forAll(amfList, mfI)
+                {
+                    label fpIndex = whichPatch(amfList[mfI].index());
+
+                    if (fpIndex != pIndex && !trisectingSlave)
+                    {
+                        continue;
+                    }
+
+                    if (patchCoupling_(pIndex))
+                    {
+                        const coupleMap& cM = patchCoupling_[pIndex].map();
+
+                        if (trisectingSlave && fpIndex != cM.slaveIndex())
+                        {
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    const coupleMap& cMap = patchCoupling_[pIndex].map();
+
+                    // Configure a face for comparison.
+                    const face& mF = faces_[amfList[mfI].index()];
+
+                    forAll(mF, pI)
+                    {
+                        if (trisectingSlave)
+                        {
+                            cF[pI] =
+                            (
+                                cMap.reverseEntityMap(coupleMap::POINT)[mF[pI]]
+                            );
+                        }
+                        else
+                        {
+                            cF[pI] =
+                            (
+                                cMap.entityMap(coupleMap::POINT)[mF[pI]]
+                            );
+                        }
+                    }
+
+                    bool matched = false;
+
+                    forAll(asfList, sfI)
+                    {
+                        const face& sF = faces_[asfList[sfI].index()];
+
+                        if (triFace::compare(triFace(cF), triFace(sF)))
+                        {
+                            if (trisectingSlave)
+                            {
+                                cMap.mapMaster
+                                (
+                                    coupleMap::FACE,
+                                    amfList[mfI].index(),
+                                    asfList[sfI].index()
+                                );
+
+                                cMap.mapSlave
+                                (
+                                    coupleMap::FACE,
+                                    asfList[sfI].index(),
+                                    amfList[mfI].index()
+                                );
+                            }
+                            else
+                            {
+                                cMap.mapSlave
+                                (
+                                    coupleMap::FACE,
+                                    amfList[mfI].index(),
+                                    asfList[sfI].index()
+                                );
+
+                                cMap.mapMaster
+                                (
+                                    coupleMap::FACE,
+                                    asfList[sfI].index(),
+                                    amfList[mfI].index()
+                                );
+                            }
+
+                            matched = true;
+
+                            break;
+                        }
+                    }
+
+                    if (!matched)
+                    {
+                        Pout<< "masterFaces: " << nl
+                            << amfList << endl;
+
+                        Pout<< "slaveFaces: " << nl
+                            << asfList << endl;
+
+                        forAll(amfList, mfI)
+                        {
+                            Pout<< amfList[mfI].index() << ": "
+                                << faces_[amfList[mfI].index()]
+                                << endl;
+                        }
+
+                        forAll(asfList, sfI)
+                        {
+                            Pout<< asfList[sfI].index() << ": "
+                                << faces_[asfList[sfI].index()]
+                                << endl;
+                        }
+
+                        FatalErrorIn
+                        (
+                            "const changeMap dynamicTopoFvMesh::trisectFace\n"
+                            "(\n"
+                            "    const label fIndex,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Failed to build coupled face maps."
+                            << abort(FatalError);
+                    }
+                }
+            }
+            else
+            if (processorCoupledEntity(fIndex))
+            {
+                // Look for matching slave edges on the patchSubMesh.
+
+            }
+        }
     }
     else
     {
@@ -3561,17 +5374,12 @@ const changeMap dynamicTopoFvMesh::trisectFace
             }
         }
 
-        // Configure edgeFaces and edgePoints for four new interior edges.
+        // Configure edgeFaces for four new interior edges.
         newQuadEdgeFaces[0] = newFaceIndex[4];
         newQuadEdgeFaces[1] = newFaceIndex[0];
         newQuadEdgeFaces[2] = newFaceIndex[3];
         newQuadEdgeFaces[3] = newFaceIndex[6];
 
-        newQuadEdgePoints[0] = faces_[fIndex][1];
-        newQuadEdgePoints[1] = apexPoint[0];
-        newQuadEdgePoints[2] = faces_[fIndex][2];
-        newQuadEdgePoints[3] = apexPoint[1];
-
         newEdgeIndex[1] =
         (
             insertEdge
@@ -3582,8 +5390,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][0]
                 ),
-                newQuadEdgeFaces,
-                newQuadEdgePoints
+                newQuadEdgeFaces
             )
         );
 
@@ -3592,11 +5399,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newQuadEdgeFaces[2] = newFaceIndex[4];
         newQuadEdgeFaces[3] = newFaceIndex[7];
 
-        newQuadEdgePoints[0] = faces_[fIndex][2];
-        newQuadEdgePoints[1] = apexPoint[0];
-        newQuadEdgePoints[2] = faces_[fIndex][0];
-        newQuadEdgePoints[3] = apexPoint[1];
-
         newEdgeIndex[2] =
         (
             insertEdge
@@ -3607,8 +5409,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][1]
                 ),
-                newQuadEdgeFaces,
-                newQuadEdgePoints
+                newQuadEdgeFaces
             )
         );
 
@@ -3617,11 +5418,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newQuadEdgeFaces[2] = newFaceIndex[5];
         newQuadEdgeFaces[3] = newFaceIndex[8];
 
-        newQuadEdgePoints[0] = faces_[fIndex][0];
-        newQuadEdgePoints[1] = apexPoint[0];
-        newQuadEdgePoints[2] = faces_[fIndex][1];
-        newQuadEdgePoints[3] = apexPoint[1];
-
         newEdgeIndex[3] =
         (
             insertEdge
@@ -3632,8 +5428,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    newPointIndex,
                    faces_[fIndex][2]
                 ),
-                newQuadEdgeFaces,
-                newQuadEdgePoints
+                newQuadEdgeFaces
             )
         );
 
@@ -3641,10 +5436,6 @@ const changeMap dynamicTopoFvMesh::trisectFace
         newTriEdgeFaces[1] = newFaceIndex[7];
         newTriEdgeFaces[2] = newFaceIndex[8];
 
-        newTriEdgePoints[0] = faces_[fIndex][0];
-        newTriEdgePoints[1] = faces_[fIndex][1];
-        newTriEdgePoints[2] = faces_[fIndex][2];
-
         newEdgeIndex[4] =
         (
             insertEdge
@@ -3655,8 +5446,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
                    apexPoint[1],
                    newPointIndex
                 ),
-                newTriEdgeFaces,
-                newTriEdgePoints
+                newTriEdgeFaces
             )
         );
 
@@ -3696,7 +5486,7 @@ const changeMap dynamicTopoFvMesh::trisectFace
         check[8][0] = apexPoint[1]; check[8][1] = faces_[fIndex][2];
 
         // Build a list of cellEdges
-        labelHashSet cellEdges;
+        DynamicList<label> cellEdges(12);
 
         forAll(cells_[owner_[fIndex]], faceI)
         {
@@ -3707,9 +5497,9 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
             forAll(fEdges, edgeI)
             {
-                if (!cellEdges.found(fEdges[edgeI]))
+                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
                 {
-                    cellEdges.insert(fEdges[edgeI]);
+                    cellEdges.append(fEdges[edgeI]);
                 }
             }
         }
@@ -3723,158 +5513,90 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
             forAll(fEdges, edgeI)
             {
-                if (!cellEdges.found(fEdges[edgeI]))
+                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
                 {
-                    cellEdges.insert(fEdges[edgeI]);
+                    cellEdges.append(fEdges[edgeI]);
                 }
             }
         }
 
         // Loop through cellEdges, and perform appropriate actions.
-        forAllIter(labelHashSet, cellEdges, eIter)
+        forAll(cellEdges, edgeI)
         {
-            const edge& edgeToCheck = edges_[eIter.key()];
+            const label ceIndex = cellEdges[edgeI];
+            const edge& edgeToCheck = edges_[ceIndex];
 
             // Check against the specified edges.
             if (edgeToCheck == check[0])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][1],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[eIter.key()]);
-                newFaceEdges[0][nE[0]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[ceIndex]);
+                newFaceEdges[0][nE[0]++] = ceIndex;
             }
 
             if (edgeToCheck == check[1])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[eIter.key()]);
-                newFaceEdges[1][nE[1]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[ceIndex]);
+                newFaceEdges[1][nE[1]++] = ceIndex;
             }
 
             if (edgeToCheck == check[2])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][1],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[eIter.key()]);
-                newFaceEdges[2][nE[2]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[ceIndex]);
+                newFaceEdges[2][nE[2]++] = ceIndex;
             }
 
             if (edgeToCheck == check[3])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][1],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[3],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[3][nE[3]++] = eIter.key();
+                newFaceEdges[3][nE[3]++] = ceIndex;
             }
 
             if (edgeToCheck == check[4])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][2],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[4],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[4][nE[4]++] = eIter.key();
+                newFaceEdges[4][nE[4]++] = ceIndex;
             }
 
             if (edgeToCheck == check[5])
             {
-                meshOps::replaceLabel
-                (
-                    faces_[fIndex][0],
-                    newPointIndex,
-                    edgePoints_[eIter.key()]
-                );
-
                 meshOps::replaceLabel
                 (
                     fIndex,
                     newFaceIndex[5],
-                    edgeFaces_[eIter.key()]
+                    edgeFaces_[ceIndex]
                 );
 
-                newFaceEdges[5][nE[5]++] = eIter.key();
+                newFaceEdges[5][nE[5]++] = ceIndex;
             }
 
             if (edgeToCheck == check[6])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][1],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[6], edgeFaces_[eIter.key()]);
-                newFaceEdges[6][nE[6]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[6], edgeFaces_[ceIndex]);
+                newFaceEdges[6][nE[6]++] = ceIndex;
             }
 
             if (edgeToCheck == check[7])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][2],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[7], edgeFaces_[eIter.key()]);
-                newFaceEdges[7][nE[7]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[7], edgeFaces_[ceIndex]);
+                newFaceEdges[7][nE[7]++] = ceIndex;
             }
 
             if (edgeToCheck == check[8])
             {
-                meshOps::insertLabel
-                (
-                    newPointIndex,
-                    faces_[fIndex][0],
-                    faces_[fIndex][1],
-                    edgePoints_[eIter.key()]
-                );
-
-                meshOps::sizeUpList(newFaceIndex[8], edgeFaces_[eIter.key()]);
-                newFaceEdges[8][nE[8]++] = eIter.key();
+                meshOps::sizeUpList(newFaceIndex[8], edgeFaces_[ceIndex]);
+                newFaceEdges[8][nE[8]++] = ceIndex;
             }
         }
 
@@ -3961,23 +5683,24 @@ const changeMap dynamicTopoFvMesh::trisectFace
 
     if (debug > 2)
     {
-        Info << "New Point:: " << newPointIndex << endl;
+        Pout<< "New Point:: " << newPointIndex << endl;
 
         const labelList& pEdges = pointEdges_[newPointIndex];
 
-        Info << "pointEdges:: " << pEdges << endl;
+        Pout<< "pointEdges:: " << pEdges << endl;
+
+        Pout<< "Added edges: " << endl;
 
-        Info << "Added edges: " << endl;
         forAll(pEdges, edgeI)
         {
-            Info << pEdges[edgeI]
-                 << ":: " << edges_[pEdges[edgeI]] << nl
-                 << " edgeFaces:: " << edgeFaces_[pEdges[edgeI]] << nl
-                 << " edgePoints:: " << edgePoints_[pEdges[edgeI]]
-                 << endl;
+            Pout<< pEdges[edgeI]
+                << ":: " << edges_[pEdges[edgeI]] << nl
+                << " edgeFaces:: " << edgeFaces_[pEdges[edgeI]] << nl
+                << endl;
         }
 
-        Info << "Added faces: " << endl;
+        Pout<< "Added faces: " << endl;
+
         forAll(newFaceIndex, faceI)
         {
             if (newFaceIndex[faceI] == -1)
@@ -3985,12 +5708,13 @@ const changeMap dynamicTopoFvMesh::trisectFace
                 continue;
             }
 
-            Info << newFaceIndex[faceI] << ":: "
-                 << faces_[newFaceIndex[faceI]]
-                 << endl;
+            Pout<< newFaceIndex[faceI] << ":: "
+                << faces_[newFaceIndex[faceI]]
+                << endl;
         }
 
-        Info << "Added cells: " << endl;
+        Pout<< "Added cells: " << endl;
+
         forAll(newCellIndex, cellI)
         {
             if (newCellIndex[cellI] == -1)
@@ -3998,9 +5722,9 @@ const changeMap dynamicTopoFvMesh::trisectFace
                 continue;
             }
 
-            Info << newCellIndex[cellI] << ":: "
-                 << cells_[newCellIndex[cellI]]
-                 << endl;
+            Pout<< newCellIndex[cellI] << ":: "
+                << cells_[newCellIndex[cellI]]
+                << endl;
         }
 
         // Write out VTK files after change
@@ -4064,9 +5788,8 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
     scalar minQuality = GREAT, minVolume = GREAT;
     scalar cQuality = 0.0, oldVolume = 0.0;
 
-    // Obtain a reference to this edge and corresponding edgePoints
+    // Obtain a reference to this edge
     const edge& edgeToCheck = edges_[eIndex];
-    const labelList& hullVertices = edgePoints_[eIndex];
 
     // Obtain point references
     const point& a = points_[edgeToCheck[0]];
@@ -4076,75 +5799,107 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
     const point& cOld = oldPoints_[edgeToCheck[1]];
 
     // Compute the mid-point of the edge
-    point midPoint = 0.5*(a + c);
-    point oldPoint = 0.5*(aOld + cOld);
+    point midPoint = 0.5 * (a + c);
+    point oldPoint = 0.5 * (aOld + cOld);
 
-    if (whichEdgePatch(eIndex) < 0)
+    DynamicList<label> eCells(10);
+
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    // Accumulate cells connected to this edge
+    forAll(eFaces, faceI)
     {
-        // Internal edge.
-        forAll(hullVertices, indexI)
+        label own = owner_[eFaces[faceI]];
+        label nei = neighbour_[eFaces[faceI]];
+
+        if (findIndex(eCells, own) == -1)
         {
-            label prevIndex = hullVertices.rcIndex(indexI);
+            eCells.append(own);
+        }
 
-            // Pick vertices off the list
-            const point& b = points_[hullVertices[prevIndex]];
-            const point& d = points_[hullVertices[indexI]];
+        if (nei == -1)
+        {
+            continue;
+        }
 
-            const point& bOld = oldPoints_[hullVertices[prevIndex]];
-            const point& dOld = oldPoints_[hullVertices[indexI]];
-
-            // Compute the quality of the upper half.
-            cQuality = tetMetric_(a, b, midPoint, d);
-
-            // Compute old volume of the upper half.
-            oldVolume = tetPointRef(aOld, bOld, oldPoint, dOld).mag();
-
-            // Check if the volume / quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
-            minVolume = Foam::min(oldVolume, minVolume);
-
-            // Compute the quality of the lower half.
-            cQuality = tetMetric_(midPoint, b, c, d);
-
-            // Compute old volume of the lower half.
-            oldVolume = tetPointRef(oldPoint, bOld, cOld, dOld).mag();
-
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
-            minVolume = Foam::min(oldVolume, minVolume);
+        if (findIndex(eCells, nei) == -1)
+        {
+            eCells.append(nei);
         }
     }
-    else
+
+    // Loop through all cells and compute quality
+    forAll(eCells, cellI)
     {
-        // Boundary edge.
-        for(label indexI = 1; indexI < hullVertices.size(); indexI++)
+        label cellIndex = eCells[cellI];
+
+        const cell& checkCell = cells_[cellIndex];
+
+        // Find two faces that don't contain the edge
+        forAll(checkCell, faceI)
         {
-            // Pick vertices off the list
-            const point& b = points_[hullVertices[indexI-1]];
-            const point& d = points_[hullVertices[indexI]];
+            const face& checkFace = faces_[checkCell[faceI]];
 
-            const point& bOld = oldPoints_[hullVertices[indexI-1]];
-            const point& dOld = oldPoints_[hullVertices[indexI]];
+            if
+            (
+                (findIndex(checkFace, edgeToCheck[0]) == -1) &&
+                (findIndex(checkFace, edgeToCheck[1]) == -1)
+            )
+            {
+                // Check orientation
+                if (owner_[checkCell[faceI]] == cellIndex)
+                {
+                    cQuality =
+                    (
+                        tetMetric_
+                        (
+                            points_[checkFace[2]],
+                            points_[checkFace[1]],
+                            points_[checkFace[0]],
+                            midPoint
+                        )
+                    );
 
-            // Compute the quality of the upper half.
-            cQuality = tetMetric_(a, b, midPoint, d);
+                    oldVolume =
+                    (
+                        tetPointRef
+                        (
+                            oldPoints_[checkFace[2]],
+                            oldPoints_[checkFace[1]],
+                            oldPoints_[checkFace[0]],
+                            oldPoint
+                        ).mag()
+                    );
+                }
+                else
+                {
+                    cQuality =
+                    (
+                        tetMetric_
+                        (
+                            points_[checkFace[0]],
+                            points_[checkFace[1]],
+                            points_[checkFace[2]],
+                            midPoint
+                        )
+                    );
 
-            // Compute old volume of the upper half.
-            oldVolume = tetPointRef(aOld, bOld, oldPoint, dOld).mag();
+                    oldVolume =
+                    (
+                        tetPointRef
+                        (
+                            oldPoints_[checkFace[0]],
+                            oldPoints_[checkFace[1]],
+                            oldPoints_[checkFace[2]],
+                            oldPoint
+                        ).mag()
+                    );
+                }
 
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
-            minVolume = Foam::min(oldVolume, minVolume);
-
-            // Compute the quality of the lower half.
-            cQuality = tetMetric_(midPoint, b, c, d);
-
-            // Compute old volume of the lower half.
-            oldVolume = tetPointRef(oldPoint, bOld, cOld, dOld).mag();
-
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
-            minVolume = Foam::min(oldVolume, minVolume);
+                // Check if the quality is worse
+                minQuality = Foam::min(cQuality, minQuality);
+                minVolume = Foam::min(oldVolume, minVolume);
+            }
         }
     }
 
@@ -4153,25 +5908,7 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
     {
         if (debug > 3 && minQuality < 0.0)
         {
-            // Write out cells for post processing.
-            labelHashSet iCells;
-
-            const labelList& eFaces = edgeFaces_[eIndex];
-
-            forAll(eFaces, faceI)
-            {
-                if (!iCells.found(owner_[eFaces[faceI]]))
-                {
-                    iCells.insert(owner_[eFaces[faceI]]);
-                }
-
-                if (!iCells.found(neighbour_[eFaces[faceI]]))
-                {
-                    iCells.insert(neighbour_[eFaces[faceI]]);
-                }
-            }
-
-            writeVTK(Foam::name(eIndex) + "_iCells", iCells.toc());
+            writeVTK(Foam::name(eIndex) + "_iCells", eCells);
         }
 
         if (debug > 2)
@@ -4181,12 +5918,13 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
                 "scalar dynamicTopoFvMesh::computeBisectionQuality"
                 "(const label eIndex) const"
             )
-                << "Bisecting edge will fall below the "
-                << "sliver threshold of: " << sliverThreshold_ << nl
-                << "Edge: " << eIndex << ": " << edgeToCheck << nl
-                << "EdgePoints: " << hullVertices << nl
-                << "Minimum Quality: " << minQuality << nl
-                << "Mid point: " << midPoint
+                << " Bisecting edge will fall below the"
+                << " sliver threshold of: " << sliverThreshold_ << nl
+                << " Edge: " << eIndex << ": " << edgeToCheck << nl
+                << " Minimum Quality: " << minQuality << nl
+                << " Minimum Volume: " << minVolume << nl
+                << " Mid point: " << midPoint << nl
+                << " Old point: " << oldPoint << nl
                 << endl;
         }
     }
@@ -4279,6 +6017,1128 @@ scalar dynamicTopoFvMesh::computeTrisectionQuality
 }
 
 
+// Slice the mesh at a particular location
+void dynamicTopoFvMesh::sliceMesh
+(
+    const labelPair& pointPair
+)
+{
+    if (debug > 1)
+    {
+        Pout<< nl << nl
+            << "Pair: " << pointPair
+            << " is to be used for mesh slicing. " << endl;
+    }
+
+    label patchIndex = -1;
+    scalar dx = 0.0;
+    vector gCentre = vector::zero;
+    FixedList<vector, 2> fC(vector::zero);
+
+    if (twoDMesh_)
+    {
+        patchIndex = whichPatch(pointPair.first());
+
+        // Fetch face centres
+        fC[0] = faces_[pointPair.first()].centre(points_);
+        fC[1] = faces_[pointPair.second()].centre(points_);
+    }
+    else
+    {
+        // Find the patch that the edge-vertex is connected to.
+        const labelList& pEdges = pointEdges_[pointPair.first()];
+
+        forAll(pEdges, edgeI)
+        {
+            if ((patchIndex = whichEdgePatch(pEdges[edgeI])) > -1)
+            {
+                break;
+            }
+        }
+
+        fC[0] = points_[pointPair.first()];
+        fC[1] = points_[pointPair.second()];
+    }
+
+    linePointRef lpr(fC[0], fC[1]);
+
+    // Specify the centre.
+    gCentre = lpr.centre();
+
+    // Specify a search distance
+    dx = lpr.mag();
+
+    // Is this edge in the vicinity of a previous slice-point?
+    if (lengthEstimator().checkOldSlices(gCentre))
+    {
+        if (debug > 1)
+        {
+            Pout<< nl << nl
+                << "Pair: " << pointPair
+                << " is too close to another slice point. "
+                << endl;
+        }
+
+        // Too close to another slice-point. Bail out.
+        return;
+    }
+
+    // Choose a box around the centre and scan all
+    // surface entities that fall into this region.
+    boundBox bBox
+    (
+        gCentre - vector(dx, dx, dx),
+        gCentre + vector(dx, dx, dx)
+    );
+
+    vector p = vector::zero, N = vector::zero;
+    Map<vector> checkPoints, surfFaces;
+    Map<edge> checkEdges;
+
+    if (twoDMesh_)
+    {
+        // Assign plane point / normal
+        p = gCentre;
+
+        vector gNorm = faces_[pointPair.first()].normal(points_);
+
+        gNorm /= (mag(gNorm) + VSMALL);
+
+        // Since this is 2D, assume XY-plane here.
+        N = (gNorm ^ vector(0.0, 0.0, 1.0));
+    }
+    else
+    {
+        // Prepare surface points / edges for Dijkstra's algorithm
+        for (label edgeI = nOldInternalEdges_; edgeI < nEdges_; edgeI++)
+        {
+            if (edgeFaces_[edgeI].empty())
+            {
+                continue;
+            }
+
+            if (whichEdgePatch(edgeI) == patchIndex)
+            {
+                const edge& surfaceEdge = edges_[edgeI];
+
+                if
+                (
+                    (bBox.contains(points_[surfaceEdge[0]])) &&
+                    (bBox.contains(points_[surfaceEdge[1]]))
+                )
+                {
+                    checkEdges.insert(edgeI, surfaceEdge);
+
+                    if (!checkPoints.found(surfaceEdge[0]))
+                    {
+                        checkPoints.insert
+                        (
+                            surfaceEdge[0],
+                            points_[surfaceEdge[0]]
+                        );
+                    }
+
+                    if (!checkPoints.found(surfaceEdge[1]))
+                    {
+                        checkPoints.insert
+                        (
+                            surfaceEdge[1],
+                            points_[surfaceEdge[1]]
+                        );
+                    }
+
+                    // Add surface faces as well.
+                    const labelList& eFaces = edgeFaces_[edgeI];
+
+                    forAll(eFaces, faceI)
+                    {
+                        if
+                        (
+                            (neighbour_[eFaces[faceI]] == -1) &&
+                            (!surfFaces.found(eFaces[faceI]))
+                        )
+                        {
+                            vector surfNorm =
+                            (
+                                faces_[eFaces[faceI]].normal(points_)
+                            );
+
+                            surfFaces.insert(eFaces[faceI], surfNorm);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (debug > 1)
+        {
+            Pout<< nl << nl
+                << " Point [0]: " << points_[pointPair.first()] << nl
+                << " Point [1]: " << points_[pointPair.second()] << endl;
+
+            if (debug > 3)
+            {
+                writeVTK("slicePoints", checkPoints.toc(), 0);
+                writeVTK("sliceEdges", checkEdges.toc(), 1);
+            }
+        }
+
+        // Find the shortest path using Dijkstra's algorithm.
+        Map<label> shortestPath;
+
+        bool foundPath =
+        (
+            meshOps::Dijkstra
+            (
+                checkPoints,
+                checkEdges,
+                pointPair.first(),
+                pointPair.second(),
+                shortestPath
+            )
+        );
+
+        // First normalize all face-normals
+        forAllIter(Map<vector>, surfFaces, sIter)
+        {
+            sIter() /= (mag(sIter()) + VSMALL);
+        }
+
+        if (foundPath)
+        {
+            // Next, take cross-products with every other
+            // vector in the list, and accumulate.
+            forAllIter(Map<vector>, surfFaces, sIterI)
+            {
+                forAllIter(Map<vector>, surfFaces, sIterJ)
+                {
+                    if (sIterI.key() != sIterJ.key())
+                    {
+                        vector n = (sIterI() ^ sIterJ());
+
+                        n /= (mag(n) + VSMALL);
+
+                        // Reverse the vector if necessary
+                        if ((N & n) < 0.0)
+                        {
+                            n = -n;
+                        }
+
+                        N += n;
+                    }
+                }
+            }
+
+            N /= (mag(N) + VSMALL);
+
+            // Obtain point position
+            p = gCentre;
+        }
+        else
+        {
+            // Probably a membrane-type configuration.
+            labelHashSet checkCells;
+
+            // Prepare a bounding cylinder with radius dx.
+            forAllIter(Map<vector>, surfFaces, sIter)
+            {
+                const face& thisFace = faces_[sIter.key()];
+
+                if (thisFace.which(pointPair.first()) > -1)
+                {
+                    N += sIter();
+                }
+            }
+
+            // Normalize and reverse.
+            N /= -(mag(N) + VSMALL);
+
+            vector a0 = points_[pointPair.first()];
+            vector a1 = points_[pointPair.second()];
+            scalar dist = mag(a1 - a0);
+
+            forAll(cells_, cellI)
+            {
+                if (cells_[cellI].empty())
+                {
+                    continue;
+                }
+
+                scalar v = 0.0;
+                vector x = vector::zero;
+
+                meshOps::cellCentreAndVolume
+                (
+                    cellI,
+                    points_,
+                    faces_,
+                    cells_,
+                    owner_,
+                    x,
+                    v
+                );
+
+                vector rx = (x - a0);
+                vector ra = (rx & N)*N;
+
+                // Check if point falls off cylinder ends.
+                if (mag(ra) > dist || mag(ra) < 0.0)
+                {
+                    continue;
+                }
+
+                vector r = (rx - ra);
+
+                // Check if the magnitude of 'r' is within radius.
+                if (mag(r) < dx)
+                {
+                    checkCells.insert(cellI);
+                }
+            }
+
+            labelList cList = checkCells.toc();
+
+            if (debug > 1)
+            {
+                Pout<< "Dijkstra's algorithm could not find a path." << endl;
+
+                if (debug > 3)
+                {
+                    writeVTK("checkCells", cList, 3);
+                }
+            }
+
+            changeMap sliceMap =
+            (
+                removeCells
+                (
+                    cList,
+                    patchIndex,
+                    "Slice_"
+                  + Foam::name(pointPair.first()) + '_'
+                  + Foam::name(pointPair.second())
+                )
+            );
+
+            if (debug)
+            {
+                checkConnectivity(10);
+            }
+
+            // Accumulate a list of projection points
+            labelHashSet pPoints;
+
+            const List<objectMap>& afList = sliceMap.addedFaceList();
+
+            forAll(afList, faceI)
+            {
+                const face& thisFace = faces_[afList[faceI].index()];
+
+                forAll(thisFace, pointI)
+                {
+                    if (!pPoints.found(thisFace[pointI]))
+                    {
+                        pPoints.insert(thisFace[pointI]);
+                    }
+                }
+            }
+
+            // Now project points in a series of intermediate steps.
+
+            // Add an entry to sliceBoxes.
+            lengthEstimator().appendBox(bBox);
+
+            return;
+        }
+    }
+
+    if (debug > 1)
+    {
+        Pout<< nl << nl
+            << " Plane point: " << p << nl
+            << " Plane normal: " << N << endl;
+    }
+
+    // Mark cells and interior faces that fall
+    // within the bounding box.
+    labelHashSet checkCells, checkFaces, splitFaces;
+    Map<bool> cellColors;
+
+    forAll(faces_, faceI)
+    {
+        if (faces_[faceI].empty())
+        {
+            continue;
+        }
+
+        if (twoDMesh_ && faces_[faceI].size() == 3)
+        {
+            continue;
+        }
+
+        vector fCentre = faces_[faceI].centre(points_);
+
+        FixedList<label, 2> cellsToCheck(-1);
+        cellsToCheck[0] = owner_[faceI];
+        cellsToCheck[1] = neighbour_[faceI];
+
+        if (bBox.contains(fCentre) && cellsToCheck[1] != -1)
+        {
+            // Add this internal face to the list.
+            checkFaces.insert(faceI);
+
+            scalar volume = 0.0;
+            vector centre = vector::zero;
+
+            forAll(cellsToCheck, cellI)
+            {
+                if (!checkCells.found(cellsToCheck[cellI]))
+                {
+                    meshOps::cellCentreAndVolume
+                    (
+                        cellsToCheck[cellI],
+                        points_,
+                        faces_,
+                        cells_,
+                        owner_,
+                        centre,
+                        volume
+                    );
+
+                    checkCells.insert(cellsToCheck[cellI]);
+
+                    if (((centre - p) & N) > 0.0)
+                    {
+                        cellColors.insert(cellsToCheck[cellI], true);
+                    }
+                    else
+                    {
+                        cellColors.insert(cellsToCheck[cellI], false);
+                    }
+                }
+            }
+        }
+    }
+
+    // Prepare a list of internal faces for mesh splitting.
+    forAllIter(labelHashSet, checkFaces, fIter)
+    {
+        if
+        (
+            cellColors[owner_[fIter.key()]]
+         != cellColors[neighbour_[fIter.key()]]
+        )
+        {
+            splitFaces.insert(fIter.key());
+        }
+
+        // Loop through all points (and associated pointEdges)
+        // for this face, and check if connected cells are also
+        // present in the checkCells/cellColors list
+        if (twoDMesh_)
+        {
+            const labelList& fEdges = faceEdges_[fIter.key()];
+
+            forAll(fEdges, edgeI)
+            {
+                const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+                forAll(eFaces, faceI)
+                {
+                    label own = owner_[eFaces[faceI]];
+                    label nei = neighbour_[eFaces[faceI]];
+
+                    if (!checkCells.found(own))
+                    {
+                        scalar volume = 0.0;
+                        vector centre = vector::zero;
+
+                        meshOps::cellCentreAndVolume
+                        (
+                            own,
+                            points_,
+                            faces_,
+                            cells_,
+                            owner_,
+                            centre,
+                            volume
+                        );
+
+                        checkCells.insert(own);
+
+                        if (((centre - p) & N) > 0.0)
+                        {
+                            cellColors.insert(own, true);
+                        }
+                        else
+                        {
+                            cellColors.insert(own, false);
+                        }
+                    }
+
+                    if (!checkCells.found(nei) && nei != -1)
+                    {
+                        scalar volume = 0.0;
+                        vector centre = vector::zero;
+
+                        meshOps::cellCentreAndVolume
+                        (
+                            nei,
+                            points_,
+                            faces_,
+                            cells_,
+                            owner_,
+                            centre,
+                            volume
+                        );
+
+                        checkCells.insert(nei);
+
+                        if (((centre - p) & N) > 0.0)
+                        {
+                            cellColors.insert(nei, true);
+                        }
+                        else
+                        {
+                            cellColors.insert(nei, false);
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            const face& faceToCheck = faces_[fIter.key()];
+
+            forAll(faceToCheck, pointI)
+            {
+                const labelList& pEdges = pointEdges_[faceToCheck[pointI]];
+
+                forAll(pEdges, edgeI)
+                {
+                    const labelList& eFaces = edgeFaces_[pEdges[edgeI]];
+
+                    forAll(eFaces, faceI)
+                    {
+                        label own = owner_[eFaces[faceI]];
+                        label nei = neighbour_[eFaces[faceI]];
+
+                        if (!checkCells.found(own))
+                        {
+                            scalar volume = 0.0;
+                            vector centre = vector::zero;
+
+                            meshOps::cellCentreAndVolume
+                            (
+                                own,
+                                points_,
+                                faces_,
+                                cells_,
+                                owner_,
+                                centre,
+                                volume
+                            );
+
+                            checkCells.insert(own);
+
+                            if (((centre - p) & N) > 0.0)
+                            {
+                                cellColors.insert(own, true);
+                            }
+                            else
+                            {
+                                cellColors.insert(own, false);
+                            }
+                        }
+
+                        if (!checkCells.found(nei) && nei != -1)
+                        {
+                            scalar volume = 0.0;
+                            vector centre = vector::zero;
+
+                            meshOps::cellCentreAndVolume
+                            (
+                                nei,
+                                points_,
+                                faces_,
+                                cells_,
+                                owner_,
+                                centre,
+                                volume
+                            );
+
+                            checkCells.insert(nei);
+
+                            if (((centre - p) & N) > 0.0)
+                            {
+                                cellColors.insert(nei, true);
+                            }
+                            else
+                            {
+                                cellColors.insert(nei, false);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (debug > 3)
+    {
+        writeVTK("splitFaces", splitFaces.toc(), 2);
+        writeVTK("checkCells", checkCells.toc(), 3);
+    }
+
+    // Pass this info into the splitInternalFaces routine.
+    splitInternalFaces
+    (
+        patchIndex,
+        splitFaces.toc(),
+        cellColors
+    );
+
+    // Add an entry to sliceBoxes.
+    lengthEstimator().appendBox(bBox);
+}
+
+
+// Add cell layer above specified patch
+const changeMap dynamicTopoFvMesh::addCellLayer
+(
+    const label patchID
+)
+{
+    changeMap map;
+
+    // Maps for added entities
+    Map<label> addedPoints;
+    Map<label> addedHEdges, addedVEdges, currentVEdges;
+    Map<label> addedHFaces, addedVFaces, currentVFaces;
+    Map<labelPair> addedCells;
+
+    // Allocate a list of patch faces
+    DynamicList<label> patchFaces(patchSizes_[patchID]);
+
+    // Loop through all patch faces and create a cell for each
+    for (label faceI = nOldInternalFaces_; faceI < faces_.size(); faceI++)
+    {
+        label pIndex = whichPatch(faceI);
+
+        if (pIndex != patchID)
+        {
+            continue;
+        }
+
+        // Add face to the list
+        patchFaces.append(faceI);
+
+        // Add a new cell
+        label cIndex = owner_[faceI];
+        scalar newLengthScale = -1.0;
+        const cell& ownCell = cells_[cIndex];
+
+        if (edgeRefinement_)
+        {
+            newLengthScale = lengthScale_[cIndex];
+        }
+
+        label newCellIndex =
+        (
+            insertCell
+            (
+                cell(ownCell.size()),
+                newLengthScale
+            )
+        );
+
+        // Update maps
+        map.addCell(newCellIndex, labelList(1, cIndex));
+        addedCells.insert(cIndex, labelPair(newCellIndex, 0));
+    }
+
+    FixedList<label, 2> mP(-1);
+
+    forAll(patchFaces, indexI)
+    {
+        label faceI = patchFaces[indexI];
+        label cIndex = owner_[faceI];
+
+        // Fetch appropriate face / cell
+        //  - Make copies, since holding references
+        //    to data within this loop is unsafe.
+        const face bFace = faces_[faceI];
+        const cell ownCell = cells_[cIndex];
+
+        // Configure a new face for insertion
+        face newHFace(bFace);
+        labelList newHFaceEdges(bFace.size(), -1);
+
+        // Get the opposing face from the cell
+        oppositeFace oFace = ownCell.opposingFace(faceI, faces_);
+
+        if (!oFace.found())
+        {
+            // Something's wrong here.
+            FatalErrorIn
+            (
+                "const changeMap dynamicTopoFvMesh::addCellLayer"
+                "(const label patchID)"
+            )
+                << " Face: " << faceI << " :: " << bFace << nl
+                << " has no opposing face in cell: "
+                << cIndex << " :: " << ownCell << nl
+                << abort(FatalError);
+        }
+
+        // Create points
+        forAll(bFace, pointI)
+        {
+            label pIndex = bFace[pointI];
+
+            // Skip if we've added this already
+            if (addedPoints.found(pIndex))
+            {
+                continue;
+            }
+
+            // Set master points
+            mP[0] = pIndex;
+            mP[1] = oFace[pointI];
+
+            label newPointIndex =
+            (
+                insertPoint
+                (
+                    0.5 * (points_[mP[0]] + points_[mP[1]]),
+                    oldPoints_[mP[0]],
+                    mP
+                )
+            );
+
+            // Update maps
+            map.addPoint(newPointIndex, mP);
+            addedPoints.insert(pIndex, newPointIndex);
+        }
+
+        // Fetch faceEdges from opposite faces.
+        //  - Make copies, since holding references is unsafe
+        const labelList bfEdges = faceEdges_[faceI];
+        const labelList ofEdges = faceEdges_[oFace.oppositeIndex()];
+
+        // Create edges for each edge of the new horizontal face
+        forAll(bfEdges, edgeI)
+        {
+            label beIndex = bfEdges[edgeI];
+
+            // Skip if we've added this already
+            if (addedHEdges.found(beIndex))
+            {
+                // Update face edges for the new horizontal face
+                newHFaceEdges[edgeI] = addedHEdges[beIndex];
+
+                continue;
+            }
+
+            // Configure the new edge
+            label oeIndex = -1;
+            const edge bEdge = edges_[beIndex];
+
+            // Build an edge for comparison
+            edge cEdge
+            (
+                oFace[bFace.which(bEdge[0])],
+                oFace[bFace.which(bEdge[1])]
+            );
+
+            forAll(ofEdges, edgeJ)
+            {
+                const edge& ofEdge = edges_[ofEdges[edgeJ]];
+
+                if (cEdge == ofEdge)
+                {
+                    oeIndex = ofEdges[edgeJ];
+                    break;
+                }
+            }
+
+            if (oeIndex < 0)
+            {
+                FatalErrorIn
+                (
+                    "const changeMap dynamicTopoFvMesh::addCellLayer"
+                    "(const label patchID)"
+                )
+                    << " Could not find comparison edge: " << cEdge
+                    << " for edge: " << bEdge
+                    << abort(FatalError);
+            }
+
+            // Fetch patch information
+            label hEdgePatch = whichEdgePatch(oeIndex);
+
+            // Set indices
+            edge newHEdge
+            (
+                addedPoints[bEdge[0]],
+                addedPoints[bEdge[1]]
+            );
+
+            // Insert a new edge with empty edgeFaces
+            label newHEdgeIndex =
+            (
+                insertEdge
+                (
+                    hEdgePatch,
+                    newHEdge,
+                    labelList(0)
+                )
+            );
+
+            // Update maps
+            map.addEdge(newHEdgeIndex);
+            addedHEdges.insert(beIndex, newHEdgeIndex);
+
+            // Update face edges for the new horizontal face
+            newHFaceEdges[edgeI] = newHEdgeIndex;
+
+            // Add a new vertical face for this edge
+            label vFaceIndex = -1;
+
+            // Find a vertical face that contains both edges
+            const labelList& beFaces = edgeFaces_[beIndex];
+
+            forAll(beFaces, faceJ)
+            {
+                const labelList& testEdges = faceEdges_[beFaces[faceJ]];
+
+                if
+                (
+                    (findIndex(testEdges, beIndex) > -1) &&
+                    (findIndex(testEdges, oeIndex) > -1)
+                )
+                {
+                    vFaceIndex = beFaces[faceJ];
+                    break;
+                }
+            }
+
+            if (vFaceIndex < 0)
+            {
+                FatalErrorIn
+                (
+                    "const changeMap dynamicTopoFvMesh::addCellLayer"
+                    "(const label patchID)"
+                )
+                    << " Could not find an appropriate vertical face"
+                    << " containing edges: " << oeIndex
+                    << " and " << beIndex
+                    << abort(FatalError);
+            }
+
+            // Find two vertical edges on this face
+            const labelList& vfEdges = faceEdges_[vFaceIndex];
+
+            forAll(vfEdges, edgeJ)
+            {
+                const edge& vfEdge = edges_[vfEdges[edgeJ]];
+
+                forAll(bEdge, i)
+                {
+                    if (vfEdge == edge(bEdge[i], cEdge[i]))
+                    {
+                        // Skip if we've added this already
+                        if (addedVEdges.found(bEdge[i]))
+                        {
+                            continue;
+                        }
+
+                        label veIndex = vfEdges[edgeJ];
+
+                        // Fetch edge patch information
+                        label vEdgePatch = whichEdgePatch(veIndex);
+
+                        // Set indices
+                        edge newVEdge
+                        (
+                            bEdge[i],
+                            addedPoints[bEdge[i]]
+                        );
+
+                        // Insert a new edge with empty edgeFaces
+                        label newVEdgeIndex =
+                        (
+                            insertEdge
+                            (
+                                vEdgePatch,
+                                newVEdge,
+                                labelList(0)
+                            )
+                        );
+
+                        // Update maps
+                        map.addEdge(newVEdgeIndex);
+                        addedVEdges.insert(bEdge[i], newVEdgeIndex);
+
+                        // Note edge indices for later renumbering
+                        currentVEdges.insert(bEdge[i], veIndex);
+                    }
+                }
+            }
+
+            // Configure the new vertical face
+            face newVFace(faces_[vFaceIndex]);
+            label newOwner = -1, newNeighbour = -1;
+
+            label oldOwner = owner_[vFaceIndex];
+            label oldNeighbour = neighbour_[vFaceIndex];
+
+            // Fetch owner / neighbour
+            newOwner = addedCells[oldOwner].first();
+
+            if (oldNeighbour > -1)
+            {
+                newNeighbour = addedCells[oldNeighbour].first();
+            }
+
+            // Replace point indices on the new face
+            forAll(bEdge, i)
+            {
+                meshOps::replaceLabel
+                (
+                    cEdge[i],
+                    addedPoints[bEdge[i]],
+                    newVFace
+                );
+            }
+
+            // Note face indices for later renumbering
+            currentVFaces.insert(beIndex, vFaceIndex);
+
+            // Check if reversal is necessary
+            if ((newNeighbour < newOwner) && (newNeighbour > -1))
+            {
+                // Flip face
+                newVFace = newVFace.reverseFace();
+
+                // Swap addressing
+                Foam::Swap(newOwner, newNeighbour);
+                Foam::Swap(oldOwner, oldNeighbour);
+            }
+
+            // Configure faceEdges for the new vertical face
+            labelList newVFaceEdges(4, -1);
+
+            newVFaceEdges[0] = beIndex;
+            newVFaceEdges[1] = newHEdgeIndex;
+            newVFaceEdges[2] = addedVEdges[bEdge[0]];
+            newVFaceEdges[3] = addedVEdges[bEdge[1]];
+
+            // Add the new vertical face
+            label newVFaceIndex =
+            (
+                insertFace
+                (
+                    whichPatch(vFaceIndex),
+                    newVFace,
+                    newOwner,
+                    newNeighbour
+                )
+            );
+
+            // Add a faceEdges entry
+            faceEdges_.append(newVFaceEdges);
+
+            // Update maps
+            map.addFace(newVFaceIndex, labelList(1, vFaceIndex));
+            addedVFaces.insert(beIndex, newVFaceIndex);
+
+            // Update face count on the new cells
+            cells_[newOwner][addedCells[oldOwner].second()++] =
+            (
+                newVFaceIndex
+            );
+
+            if (newNeighbour > -1)
+            {
+                cells_[newNeighbour][addedCells[oldNeighbour].second()++] =
+                (
+                    newVFaceIndex
+                );
+            }
+
+            // Size up edgeFaces for each edge
+            forAll(newVFaceEdges, edgeJ)
+            {
+                label vfeIndex = newVFaceEdges[edgeJ];
+
+                meshOps::sizeUpList
+                (
+                    newVFaceIndex,
+                    edgeFaces_[vfeIndex]
+                );
+            }
+        }
+
+        // Add a new interior face, with identical orientation
+        forAll(newHFace, pointI)
+        {
+            newHFace[pointI] = addedPoints[newHFace[pointI]];
+        }
+
+        // Add the new horizontal face
+        label newHFaceIndex =
+        (
+            insertFace
+            (
+                -1,
+                newHFace,
+                cIndex,
+                addedCells[cIndex].first()
+            )
+        );
+
+        // Add a faceEdges entry
+        faceEdges_.append(newHFaceEdges);
+
+        // Update maps
+        map.addFace(newHFaceIndex, labelList(1, faceI));
+        addedHFaces.insert(faceI, newHFaceIndex);
+
+        // Replace index on the old cell
+        meshOps::replaceLabel
+        (
+            faceI,
+            newHFaceIndex,
+            cells_[cIndex]
+        );
+
+        // Update face count on the new cell
+        label newCellIndex = addedCells[cIndex].first();
+
+        // Modify owner for the existing boundary face
+        owner_[faceI] = newCellIndex;
+
+        cells_[newCellIndex][addedCells[cIndex].second()++] = faceI;
+        cells_[newCellIndex][addedCells[cIndex].second()++] = newHFaceIndex;
+
+        // Size up edgeFaces for each edge
+        forAll(newHFaceEdges, edgeI)
+        {
+            label hfeIndex = newHFaceEdges[edgeI];
+
+            meshOps::sizeUpList
+            (
+                newHFaceIndex,
+                edgeFaces_[hfeIndex]
+            );
+        }
+    }
+
+    // Renumber vertical edges
+    forAllConstIter(Map<label>, currentVEdges, eIter)
+    {
+        // Fetch reference to edge
+        edge& curEdge = edges_[eIter()];
+
+        if (curEdge[0] == eIter.key())
+        {
+            curEdge[0] = addedPoints[eIter.key()];
+        }
+
+        if (curEdge[1] == eIter.key())
+        {
+            curEdge[1] = addedPoints[eIter.key()];
+        }
+
+        // Size down pointEdges
+        if (!twoDMesh_)
+        {
+            meshOps::sizeDownList
+            (
+                eIter(),
+                pointEdges_[eIter.key()]
+            );
+
+            meshOps::sizeUpList
+            (
+                eIter(),
+                pointEdges_[addedPoints[eIter.key()]]
+            );
+        }
+    }
+
+    // Renumber vertical faces
+    forAllConstIter(Map<label>, currentVFaces, fIter)
+    {
+        // Fetch reference to existing edge
+        const edge& bEdge = edges_[fIter.key()];
+
+        // Replace point indices on vertical face
+        forAll(bEdge, i)
+        {
+            meshOps::replaceLabel
+            (
+                bEdge[i],
+                addedPoints[bEdge[i]],
+                faces_[fIter()]
+            );
+        }
+
+        // Replace edge on the existing vertical face
+        meshOps::replaceLabel
+        (
+            fIter.key(),
+            addedHEdges[fIter.key()],
+            faceEdges_[fIter()]
+        );
+
+        // Remove old face on existing boundary edge
+        meshOps::sizeDownList
+        (
+            fIter(),
+            edgeFaces_[fIter.key()]
+        );
+
+        // Add old face to new horizontal edge
+        meshOps::sizeUpList
+        (
+            fIter(),
+            edgeFaces_[addedHEdges[fIter.key()]]
+        );
+    }
+
+    // Now that all old / new cells possess correct connectivity,
+    // compute mapping information.
+    const List<objectMap>& afList = map.addedFaceList();
+
+    forAll(afList, indexI)
+    {
+        label parent = afList[indexI].masterObjects()[0];
+
+        if (whichPatch(afList[indexI].index()) == -1)
+        {
+            // Interior faces get default mapping
+            if (whichPatch(parent) == -1)
+            {
+                setFaceMapping(parent);
+            }
+
+            setFaceMapping(afList[indexI].index());
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+
 // Split a set of internal faces into boundary faces
 //   - Add boundary faces and edges to the patch specified by 'patchIndex'
 //   - Cell color should specify a binary value dictating either side
@@ -4539,7 +7399,7 @@ void dynamicTopoFvMesh::splitInternalFaces
     }
 
     // For every edge in the list, add a new one.
-    // We'll deal with correcting edgeFaces and edgePoints later.
+    // We'll deal with correcting edgeFaces later.
     forAllIter(Map<label>, mirrorEdgeLabels[0], eIter)
     {
         // Obtain copies for the append method
@@ -4556,8 +7416,7 @@ void dynamicTopoFvMesh::splitInternalFaces
                     mirrorPointLabels[origEdge[0]],
                     mirrorPointLabels[origEdge[1]]
                 ),
-                newEdgeFaces,
-                labelList(0)
+                newEdgeFaces
             )
         );
 
@@ -4571,8 +7430,7 @@ void dynamicTopoFvMesh::splitInternalFaces
                 (
                     patchIndex,
                     origEdge,
-                    newEdgeFaces,
-                    labelList(0)
+                    newEdgeFaces
                 )
             );
 
@@ -4765,48 +7623,6 @@ void dynamicTopoFvMesh::splitInternalFaces
                 }
             }
         }
-
-        // Scan edges connected to mirror points,
-        // and correct any edgePoints entries for
-        // edges connected to the other vertex.
-        forAllIter(Map<label>, mirrorPointLabels, pIter)
-        {
-            const labelList& pEdges = pointEdges_[pIter()];
-
-            forAll(pEdges, edgeI)
-            {
-                label otherVertex = edges_[pEdges[edgeI]].otherVertex(pIter());
-
-                // Scan edgePoints for edges connected to this point
-                const labelList& opEdges = pointEdges_[otherVertex];
-
-                forAll(opEdges, edgeJ)
-                {
-                    labelList& ePoints = edgePoints_[opEdges[edgeJ]];
-
-                    forAll(ePoints, pointI)
-                    {
-                        if (mirrorPointLabels.found(ePoints[pointI]))
-                        {
-                            // Replace this point with the mirror point
-                            ePoints[pointI] =
-                            (
-                                mirrorPointLabels[ePoints[pointI]]
-                            );
-                        }
-                    }
-                }
-            }
-        }
-
-        // Build edgePoints for new edges
-        forAll(mirrorEdgeLabels, indexI)
-        {
-            forAllIter(Map<label>, mirrorEdgeLabels[indexI], eIter)
-            {
-                buildEdgePoints(eIter());
-            }
-        }
     }
 
     // Now that we're done with the internal faces, remove them.
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
index 490d7f6b9..0fac8a8c6 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
@@ -25,9 +25,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "Stack.H"
+#include "triFace.H"
 #include "objectMap.H"
 #include "changeMap.H"
 #include "multiThreader.H"
+#include "coupledInfo.H"
 #include "dynamicTopoFvMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -37,16 +39,19 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// Method for the collapse of a quad-face in 2D
+// Method to collapse a quad-face in 2D
 // - Returns a changeMap with a type specifying:
+//    -3: Collapse failed since face was on a noRefinement patch.
 //    -1: Collapse failed since max number of topo-changes was reached.
 //     0: Collapse could not be performed.
 //     1: Collapsed to first node.
 //     2: Collapsed to second node.
+//     3: Collapse to mid-point.
 // - overRideCase is used to force a certain collapse configuration.
 //    -1: Use this value to let collapseQuadFace decide a case.
 //     1: Force collapse to first node.
 //     2: Force collapse to second node.
+//     3: Force collapse to mid-point.
 // - checkOnly performs a feasibility check and returns without modifications.
 const changeMap dynamicTopoFvMesh::collapseQuadFace
 (
@@ -59,8 +64,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     // Figure out which thread this is...
     label tIndex = self();
 
-    // Prepare the changeMap
+    // Prepare the changeMaps
     changeMap map;
+    List<changeMap> slaveMaps;
+    bool collapsingSlave = false;
 
     if
     (
@@ -75,8 +82,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     }
 
     // Check if edgeRefinements are to be avoided on patch.
-    if (lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
+    if (baseMesh_.lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
     {
+        map.type() = -3;
+
         return map;
     }
 
@@ -91,7 +100,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             "(\n"
             "    const label fIndex,\n"
             "    label overRideCase,\n"
-            "    bool checkOnly\n"
+            "    bool checkOnly,\n"
+            "    bool forceOp\n"
             ")\n"
         )
             << " Invalid index: " << fIndex
@@ -99,51 +109,914 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     }
 
     // Define the edges on the face to be collapsed
-    FixedList<edge,4> checkEdge(edge(-1,-1));
+    FixedList<edge,4> checkEdge(edge(-1, -1));
     FixedList<label,4> checkEdgeIndex(-1);
 
     // Define checkEdges
-    checkEdgeIndex[0] = getTriBoundaryEdge(fIndex);
-    checkEdge[0] = edges_[checkEdgeIndex[0]];
+    getCheckEdges(fIndex, (*this), map, checkEdge, checkEdgeIndex);
 
-    const labelList& fEdges = faceEdges_[fIndex];
+    // Determine the common vertices for the first and second edges
+    label cv0 = checkEdge[1].commonVertex(checkEdge[0]);
+    label cv1 = checkEdge[1].commonVertex(checkEdge[3]);
+    label cv2 = checkEdge[2].commonVertex(checkEdge[0]);
+    label cv3 = checkEdge[2].commonVertex(checkEdge[3]);
 
-    forAll(fEdges, edgeI)
+    // If coupled modification is set, and this is a
+    // master face, collapse its slaves first.
+    bool localCouple = false, procCouple = false;
+
+    if (coupledModification_)
     {
-        if (checkEdgeIndex[0] != fEdges[edgeI])
+        const face& fCheck = faces_[fIndex];
+
+        const label faceEnum = coupleMap::FACE;
+        const label pointEnum = coupleMap::POINT;
+
+        // Is this a locally coupled edge (either master or slave)?
+        if (locallyCoupledEntity(fIndex, true))
         {
-            const edge& thisEdge = edges_[fEdges[edgeI]];
+            localCouple = true;
+            procCouple = false;
+        }
+        else
+        if (processorCoupledEntity(fIndex))
+        {
+            procCouple = true;
+            localCouple = false;
+        }
 
-            if
-            (
-                checkEdge[0].start() == thisEdge[0] ||
-                checkEdge[0].start() == thisEdge[1]
-            )
+        if (localCouple && !procCouple)
+        {
+            // Determine the slave index.
+            label sIndex = -1, pIndex = -1;
+
+            forAll(patchCoupling_, patchI)
             {
-                checkEdgeIndex[1] = fEdges[edgeI];
-                checkEdge[1] = thisEdge;
+                if (patchCoupling_(patchI))
+                {
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
 
-                // Update the map
-                map.firstEdge() = checkEdgeIndex[1];
+                    if ((sIndex = cMap.findSlave(faceEnum, fIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        break;
+                    }
+
+                    // The following bit happens only during the sliver
+                    // exudation process, since slave edges are
+                    // usually not added to the coupled edge-stack.
+                    if ((sIndex = cMap.findMaster(faceEnum, fIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        // Notice that we are collapsing a slave edge first.
+                        collapsingSlave = true;
+
+                        break;
+                    }
+                }
             }
-            else
-            if
-            (
-                checkEdge[0].end() == thisEdge[0] ||
-                checkEdge[0].end() == thisEdge[1]
-            )
-            {
-                checkEdgeIndex[2] = fEdges[edgeI];
-                checkEdge[2] = thisEdge;
 
-                // Update the map
-                map.secondEdge() = checkEdgeIndex[2];
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap "
+                    "dynamicTopoFvMesh::collapseQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Face: " << fIndex << ": " << fCheck << nl
+                    << abort(FatalError);
             }
             else
             {
-                checkEdgeIndex[3] = fEdges[edgeI];
-                checkEdge[3] = thisEdge;
+                // If we've found the slave, size up the list
+                meshOps::sizeUpList
+                (
+                    changeMap(),
+                    slaveMaps
+                );
+
+                // Save index and patch for posterity
+                slaveMaps[0].index() = sIndex;
+                slaveMaps[0].patchIndex() = pIndex;
             }
+
+            if (debug > 1)
+            {
+                Pout<< nl << " >> Collapsing slave face: " << sIndex
+                    << " for master face: " << fIndex << endl;
+            }
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            // If this is a new entity, bail out for now.
+            // This will be handled at the next time-step.
+            if (fIndex >= nOldFaces_)
+            {
+                return map;
+            }
+
+            // Check slaves
+            forAll(procIndices_, pI)
+            {
+                // Fetch reference to subMeshes
+                const coupledInfo& sendMesh = sendMeshes_[pI];
+                const coupledInfo& recvMesh = recvMeshes_[pI];
+
+                const coupleMap& scMap = sendMesh.map();
+                const coupleMap& rcMap = recvMesh.map();
+
+                // If this face was sent to a lower-ranked
+                // processor, skip it.
+                if (procIndices_[pI] < Pstream::myProcNo())
+                {
+                    if (scMap.reverseEntityMap(faceEnum).found(fIndex))
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Face: " << fIndex
+                                << "::" << fCheck
+                                << " was sent to proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+                }
+
+                label sIndex = -1;
+
+                if ((sIndex = rcMap.findSlave(faceEnum, fIndex)) > -1)
+                {
+                    // Check if a lower-ranked processor is
+                    // handling this face
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Face: " << fIndex
+                                << "::" << fCheck
+                                << " is handled by proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Save index and patch for posterity
+                    slaveMaps[curIndex].index() = sIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+                }
+                else
+                if
+                (
+                    (
+                        rcMap.findSlave(pointEnum, cv0) > -1 &&
+                        rcMap.findSlave(pointEnum, cv1) > -1
+                    )
+                 || (
+                        rcMap.findSlave(pointEnum, cv2) > -1 &&
+                        rcMap.findSlave(pointEnum, cv3) > -1
+                    )
+                )
+                {
+                    // An edge-only coupling exists.
+
+                    // Check if a lower-ranked processor is
+                    // handling this face
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                         if (debug > 3)
+                         {
+                             Pout<< "Face edge on: " << fIndex
+                                 << "::" << fCheck
+                                 << " is handled by proc: "
+                                 << procIndices_[pI]
+                                 << ", so bailing out."
+                                 << endl;
+                         }
+
+                         return map;
+                    }
+
+                    label p0 = rcMap.findSlave(pointEnum, cv0);
+                    label p1 = rcMap.findSlave(pointEnum, cv1);
+
+                    label p2 = rcMap.findSlave(pointEnum, cv2);
+                    label p3 = rcMap.findSlave(pointEnum, cv3);
+
+                    edge cEdge(-1, -1);
+                    label edgeCouple = -1;
+
+                    if ((p0 > -1 && p1 > -1) && (p2 == -1 && p3 == -1))
+                    {
+                        cEdge[0] = p0;
+                        cEdge[1] = p1;
+
+                        edgeCouple = 1;
+                        sIndex = readLabel(map.lookup("firstEdge"));
+                    }
+                    else
+                    if ((p0 == -1 && p1 == -1) && (p2 > -1 && p3 > -1))
+                    {
+                        cEdge[0] = p2;
+                        cEdge[1] = p3;
+
+                        edgeCouple = 2;
+                        sIndex = readLabel(map.lookup("secondEdge"));
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Unfortunately, since no edge maps are
+                    // available in 2D, loop through boundary
+                    // faces on subMesh and get the right edge
+                    label seIndex = -1;
+
+                    const dynamicTopoFvMesh& sMesh = recvMesh.subMesh();
+
+                    for
+                    (
+                        label faceI = sMesh.nOldInternalFaces_;
+                        faceI < sMesh.faceEdges_.size();
+                        faceI++
+                    )
+                    {
+                        const labelList& fEdges = sMesh.faceEdges_[faceI];
+
+                        forAll(fEdges, edgeI)
+                        {
+                            if (sMesh.edges_[fEdges[edgeI]] == cEdge)
+                            {
+                                seIndex = fEdges[edgeI];
+                                break;
+                            }
+                        }
+
+                        if (seIndex > -1)
+                        {
+                            break;
+                        }
+                    }
+
+                    if (seIndex == -1)
+                    {
+                        Pout<< "Face edge on: " << fIndex
+                            << "::" << fCheck
+                            << " sIndex: " << sIndex
+                            << " could not be found."
+                            << abort(FatalError);
+                    }
+
+                    // Save index and patch for posterity
+                    //  - Negate the index to signify edge coupling
+                    slaveMaps[curIndex].index() = -seIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+
+                    // Save edgeCouple as well, so that
+                    // another map comparison is avoided.
+                    slaveMaps[curIndex].type() = edgeCouple;
+                }
+            }
+        }
+        else
+        {
+            // Something's wrong with coupling maps
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap "
+                "dynamicTopoFvMesh::collapseQuadFace\n"
+                "(\n"
+                "    const label fIndex,\n"
+                "    label overRideCase,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " localCouple: " << localCouple << nl
+                << " procCouple: " << procCouple << nl
+                << " Face: " << fIndex << ": " << fCheck << nl
+                << abort(FatalError);
+        }
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        // Test the master face for collapse, and decide on a case
+        changeMap masterMap = collapseQuadFace(fIndex, -1, true, forceOp);
+
+        // Turn it back on.
+        setCoupledModification();
+
+        // Master couldn't perform collapse
+        if (masterMap.type() <= 0)
+        {
+            return masterMap;
+        }
+
+        // For edge-only coupling, define the points for checking
+        List<FixedList<point, 2> > slaveMoveNewPoint(slaveMaps.size());
+        List<FixedList<point, 2> > slaveMoveOldPoint(slaveMaps.size());
+
+        // Now check each of the slaves for collapse feasibility
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label slaveOverRide = -1;
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+            const coupleMap* cMapPtr = NULL;
+
+            if (localCouple)
+            {
+                cMapPtr = &(patchCoupling_[pI].map());
+            }
+            else
+            if (procCouple)
+            {
+                const dynamicTopoFvMesh& sMesh =
+                (
+                    recvMeshes_[pI].subMesh()
+                );
+
+                cMapPtr = &(recvMeshes_[pI].map());
+
+                if (debug > 3)
+                {
+                    if (sIndex < 0)
+                    {
+                        Pout<< "Checking slave edge: " << mag(sIndex)
+                            << "::" << sMesh.edges_[mag(sIndex)]
+                            << " on proc: " << procIndices_[pI]
+                            << " for master face: " << fIndex
+                            << " using collapseCase: " << masterMap.type()
+                            << endl;
+                    }
+                    else
+                    {
+                        Pout<< "Checking slave face: " << sIndex
+                            << "::" << sMesh.faces_[sIndex]
+                            << " on proc: " << procIndices_[pI]
+                            << " for master face: " << fIndex
+                            << " using collapseCase: " << masterMap.type()
+                            << endl;
+                    }
+                }
+            }
+
+            // Define an overRide case for the slave
+            FixedList<edge, 2> mEdge(edge(-1, -1)), sEdge(edge(-1, -1));
+
+            if (collapsingSlave)
+            {
+                const Map<label>& rPointMap =
+                (
+                    cMapPtr->reverseEntityMap(pointEnum)
+                );
+
+                if (sIndex < 0)
+                {
+                    if (slaveMap.type() == 1)
+                    {
+                        mEdge[0][0] = rPointMap[cv0];
+                        mEdge[0][1] = rPointMap[cv1];
+                    }
+                    else
+                    if (slaveMap.type() == 2)
+                    {
+                        mEdge[0][0] = rPointMap[cv2];
+                        mEdge[0][1] = rPointMap[cv3];
+                    }
+                }
+                else
+                {
+                    mEdge[0][0] = rPointMap[cv0];
+                    mEdge[0][1] = rPointMap[cv1];
+
+                    mEdge[1][0] = rPointMap[cv2];
+                    mEdge[1][1] = rPointMap[cv3];
+                }
+            }
+            else
+            {
+                const Map<label>& pointMap =
+                (
+                    cMapPtr->entityMap(pointEnum)
+                );
+
+                if (sIndex < 0)
+                {
+                    if (slaveMap.type() == 1)
+                    {
+                        mEdge[0][0] = pointMap[cv0];
+                        mEdge[0][1] = pointMap[cv1];
+                    }
+                    else
+                    if (slaveMap.type() == 2)
+                    {
+                        mEdge[0][0] = pointMap[cv2];
+                        mEdge[0][1] = pointMap[cv3];
+                    }
+                }
+                else
+                {
+                    mEdge[0][0] = pointMap[cv0];
+                    mEdge[0][1] = pointMap[cv1];
+
+                    mEdge[1][0] = pointMap[cv2];
+                    mEdge[1][1] = pointMap[cv3];
+                }
+            }
+
+            // Determine checkEdges for the slave
+            FixedList<edge,4> slaveCheckEdge(edge(-1, -1));
+            FixedList<label,4> slaveCheckEdgeIndex(-1);
+
+            if (localCouple)
+            {
+                getCheckEdges
+                (
+                    sIndex,
+                    (*this),
+                    slaveMap,
+                    slaveCheckEdge,
+                    slaveCheckEdgeIndex
+                );
+
+                sEdge[0] = edges_[readLabel(slaveMap.lookup("firstEdge"))];
+                sEdge[1] = edges_[readLabel(slaveMap.lookup("secondEdge"))];
+            }
+            else
+            if (procCouple)
+            {
+                const dynamicTopoFvMesh& sMesh =
+                (
+                    recvMeshes_[pI].subMesh()
+                );
+
+                if (sIndex < 0)
+                {
+                    sEdge[0] = sMesh.edges_[mag(sIndex)];
+                }
+                else
+                {
+                    getCheckEdges
+                    (
+                        sIndex,
+                        sMesh,
+                        slaveMap,
+                        slaveCheckEdge,
+                        slaveCheckEdgeIndex
+                    );
+
+                    sEdge[0] =
+                    (
+                        sMesh.edges_[readLabel(slaveMap.lookup("firstEdge"))]
+                    );
+
+                    sEdge[1] =
+                    (
+                        sMesh.edges_[readLabel(slaveMap.lookup("secondEdge"))]
+                    );
+                }
+            }
+
+            // Compare edge orientations for edge-only coupling
+            label compVal = -2;
+
+            // Perform a topological comparison.
+            switch (masterMap.type())
+            {
+                case 1:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI][0] = points_[cv0];
+                        slaveMoveNewPoint[slaveI][1] = points_[cv1];
+
+                        slaveMoveOldPoint[slaveI][0] = oldPoints_[cv0];
+                        slaveMoveOldPoint[slaveI][1] = oldPoints_[cv1];
+                    }
+                    else
+                    if (mEdge[0] == sEdge[0])
+                    {
+                        slaveOverRide = 1;
+                    }
+                    else
+                    if (mEdge[1] == sEdge[0])
+                    {
+                        slaveOverRide = 2;
+                    }
+                    else
+                    {
+                        // Write out for for post-processing
+                        writeVTK("mFace_" + Foam::name(fIndex), fIndex, 2);
+
+                        FatalErrorIn
+                        (
+                            "\n"
+                            "const changeMap "
+                            "dynamicTopoFvMesh::collapseQuadFace\n"
+                            "(\n"
+                            "    const label fIndex,\n"
+                            "    label overRideCase,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Coupled collapse failed." << nl
+                            << "Masters: " << nl
+                            << checkEdgeIndex[1] << ": "
+                            << checkEdge[1] << nl
+                            << checkEdgeIndex[2] << ": "
+                            << checkEdge[2] << nl
+                            << "Slaves: " << nl
+                            << readLabel(slaveMap.lookup("firstEdge")) << ": "
+                            << sEdge[0] << nl
+                            << readLabel(slaveMap.lookup("secondEdge")) << ": "
+                            << sEdge[1] << nl
+                            << abort(FatalError);
+                    }
+
+                    break;
+                }
+
+                case 2:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI][0] = points_[cv2];
+                        slaveMoveNewPoint[slaveI][1] = points_[cv3];
+
+                        slaveMoveOldPoint[slaveI][0] = oldPoints_[cv2];
+                        slaveMoveOldPoint[slaveI][1] = oldPoints_[cv3];
+                    }
+                    else
+                    if (mEdge[1] == sEdge[1])
+                    {
+                        slaveOverRide = 2;
+                    }
+                    else
+                    if (mEdge[0] == sEdge[1])
+                    {
+                        slaveOverRide = 1;
+                    }
+                    else
+                    {
+                        // Write out for for post-processing
+                        writeVTK("mFace_" + Foam::name(fIndex), fIndex, 2);
+
+                        FatalErrorIn
+                        (
+                            "\n"
+                            "const changeMap "
+                            "dynamicTopoFvMesh::collapseQuadFace\n"
+                            "(\n"
+                            "    const label fIndex,\n"
+                            "    label overRideCase,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Coupled collapse failed." << nl
+                            << "Masters: " << nl
+                            << checkEdgeIndex[1] << ": "
+                            << checkEdge[1] << nl
+                            << checkEdgeIndex[2] << ": "
+                            << checkEdge[2] << nl
+                            << "Slaves: " << nl
+                            << readLabel(slaveMap.lookup("firstEdge")) << ": "
+                            << sEdge[0] << nl
+                            << readLabel(slaveMap.lookup("secondEdge")) << ": "
+                            << sEdge[1] << nl
+                            << abort(FatalError);
+                    }
+
+                    break;
+                }
+
+                case 3:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI][0] =
+                        (
+                            0.5 * (points_[cv0] + points_[cv2])
+                        );
+
+                        slaveMoveNewPoint[slaveI][1] =
+                        (
+                            0.5 * (points_[cv1] + points_[cv3])
+                        );
+
+                        slaveMoveOldPoint[slaveI][0] =
+                        (
+                            0.5 * (oldPoints_[cv0] + oldPoints_[cv2])
+                        );
+
+                        slaveMoveOldPoint[slaveI][1] =
+                        (
+                            0.5 * (oldPoints_[cv1] + oldPoints_[cv3])
+                        );
+                    }
+                    else
+                    {
+                        overRideCase = 3;
+                    }
+
+                    break;
+                }
+            }
+
+            if (sIndex < 0)
+            {
+                // Check edge orientation
+                compVal = edge::compare(mEdge[0], sEdge[0]);
+
+                // Swap components if necessary
+                if (compVal == -1)
+                {
+                    Foam::Swap
+                    (
+                        slaveMoveNewPoint[slaveI][0],
+                        slaveMoveNewPoint[slaveI][1]
+                    );
+
+                    Foam::Swap
+                    (
+                        slaveMoveOldPoint[slaveI][0],
+                        slaveMoveOldPoint[slaveI][1]
+                    );
+                }
+                else
+                if (compVal != 1)
+                {
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "const changeMap "
+                        "dynamicTopoFvMesh::collapseQuadFace\n"
+                        "(\n"
+                        "    const label fIndex,\n"
+                        "    label overRideCase,\n"
+                        "    bool checkOnly,\n"
+                        "    bool forceOp\n"
+                        ")\n"
+                    )
+                        << "Coupled topo-change for slave failed." << nl
+                        << " Dissimilar edges: " << nl
+                        << " mEdge: " << mEdge << nl
+                        << " sEdge: " << sEdge << nl
+                        << " masterMap type: " << masterMap.type() << nl
+                        << abort(FatalError);
+                }
+            }
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Test the slave face
+            if (localCouple)
+            {
+                slaveMap =
+                (
+                    collapseQuadFace(sIndex, slaveOverRide, true, forceOp)
+                );
+            }
+            else
+            if (procCouple)
+            {
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                if (sIndex < 0)
+                {
+                    // Edge-based coupling
+
+                    // Build a hull of cells and tri-faces
+                    // that are connected to the slave edge
+                    labelList slaveHullCells;
+                    labelList slaveHullTriFaces;
+
+                    meshOps::constructPrismHull
+                    (
+                        mag(sIndex),
+                        sMesh.faces_,
+                        sMesh.cells_,
+                        sMesh.owner_,
+                        sMesh.neighbour_,
+                        sMesh.edgeFaces_,
+                        slaveHullTriFaces,
+                        slaveHullCells
+                    );
+
+                    bool infeasible = false;
+
+                    // Keep track of resulting cell quality,
+                    // if collapse is indeed feasible
+                    scalar slaveCollapseQuality(GREAT);
+
+                    // Check whether the collapse is possible.
+                    if
+                    (
+                        checkCollapse
+                        (
+                            sMesh,
+                            slaveHullTriFaces,
+                            FixedList<label, 2>(-1),
+                            FixedList<label, 2>(-1),
+                            sEdge[0],
+                            slaveMoveNewPoint[slaveI],
+                            slaveMoveOldPoint[slaveI],
+                            slaveCollapseQuality,
+                            false,
+                            forceOp
+                        )
+                    )
+                    {
+                        infeasible = true;
+                    }
+
+                    if (infeasible)
+                    {
+                        slaveMap.type() = 0;
+                    }
+                    else
+                    {
+                        slaveMap.type() = 1;
+                    }
+                }
+                else
+                {
+                    // Edge-based coupling
+                    slaveMap =
+                    (
+                        sMesh.collapseQuadFace
+                        (
+                            sIndex,
+                            slaveOverRide,
+                            true,
+                            forceOp
+                        )
+                    );
+                }
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            if (slaveMap.type() <= 0)
+            {
+                // Slave couldn't perform collapse.
+                map.type() = -2;
+
+                return map;
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
+        }
+
+        // Next collapse each slave face (for real this time...)
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+            label slaveOverRide = slaveMap.type();
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Collapse the slave
+            if (localCouple)
+            {
+                slaveMap =
+                (
+                    collapseQuadFace(sIndex, slaveOverRide, false, forceOp)
+                );
+            }
+            else
+            {
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                if (sIndex < 0)
+                {
+                    // Edge-based coupling
+                    const coupleMap& cMap = recvMeshes_[pI].map();
+
+                    // Fetch the slave edge
+                    edge sEdge = sMesh.edges_[mag(sIndex)];
+
+                    // Move points to new location,
+                    // and update operation into coupleMap
+                    sMesh.points_[sEdge[0]] = slaveMoveNewPoint[slaveI][0];
+                    sMesh.points_[sEdge[1]] = slaveMoveNewPoint[slaveI][1];
+
+                    sMesh.oldPoints_[sEdge[0]] = slaveMoveOldPoint[slaveI][0];
+                    sMesh.oldPoints_[sEdge[1]] = slaveMoveOldPoint[slaveI][1];
+
+                    cMap.pushOperation
+                    (
+                        sEdge[0],
+                        coupleMap::MOVE_POINT,
+                        slaveMoveNewPoint[slaveI][0],
+                        slaveMoveOldPoint[slaveI][0]
+                    );
+
+                    cMap.pushOperation
+                    (
+                        sEdge[1],
+                        coupleMap::MOVE_POINT,
+                        slaveMoveNewPoint[slaveI][1],
+                        slaveMoveOldPoint[slaveI][1]
+                    );
+
+                    // Force operation to succeed
+                    slaveMap.type() = 1;
+                }
+                else
+                {
+                    // Face-based coupling
+                    slaveMap =
+                    (
+                        sMesh.collapseQuadFace
+                        (
+                            sIndex,
+                            slaveOverRide,
+                            false,
+                            forceOp
+                        )
+                    );
+                }
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            // The final operation has to succeed.
+            if (slaveMap.type() <= 0)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap "
+                    "dynamicTopoFvMesh::collapseQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled topo-change for slave failed." << nl
+                    << " Face: " << fIndex << ": " << fCheck << nl
+                    << " Slave index: " << sIndex << nl
+                    << " Patch index: " << pI << nl
+                    << " Type: " << slaveMap.type() << nl
+                    << abort(FatalError);
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
         }
     }
 
@@ -179,8 +1052,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     label c0 = owner_[fIndex], c1 = neighbour_[fIndex];
 
     // Define variables for the prism-face calculation
-    FixedList<face,2> c0BdyFace, c0IntFace, c1BdyFace, c1IntFace;
-    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
+    FixedList<label,2> c0BdyIndex(-1), c0IntIndex(-1);
+    FixedList<label,2> c1BdyIndex(-1), c1IntIndex(-1);
+    FixedList<face,2> c0BdyFace(face(3)), c0IntFace(face(4));
+    FixedList<face,2> c1BdyFace(face(3)), c1IntFace(face(4));
 
     // Find the prism-faces
     meshOps::findPrismFaces
@@ -245,7 +1120,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     "(\n"
                     "    const label fIndex,\n"
                     "    label overRideCase,\n"
-                    "    bool checkOnly\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
                     ")\n"
                 )   << "Collapsing an internal face that "
                     << "lies on two boundary patches. "
@@ -311,12 +1187,6 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     FixedList<point, 2> newPoint(vector::zero);
     FixedList<point, 2> oldPoint(vector::zero);
 
-    // Determine the common vertices for the first and second edges
-    label cv0 = checkEdge[1].commonVertex(checkEdge[0]);
-    label cv1 = checkEdge[1].commonVertex(checkEdge[3]);
-    label cv2 = checkEdge[2].commonVertex(checkEdge[0]);
-    label cv3 = checkEdge[2].commonVertex(checkEdge[3]);
-
     // Replacement check points
     FixedList<label,2> original(-1), replacement(-1);
 
@@ -387,77 +1257,23 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 )
             );
 
-            // Specify off-centering
-            scalar offCentre = (c1 == -1) ? 0.0 : 1.0;
-
-            FixedList<vector,2> te(vector::zero), xf(vector::zero);
-            FixedList<vector,2> ne(vector::zero), nf(vector::zero);
-
-            // Compute tangent-to-edge
-            te[0] = (oldPoints_[replacement[0]] - oldPoints_[original[0]]);
-            te[1] = (oldPoints_[replacement[1]] - oldPoints_[original[1]]);
-
-            // Compute face position / normal
-            if (c0BdyFace[0].which(original[0]) > -1)
-            {
-                xf[0] = c0BdyFace[0].centre(oldPoints_);
-                nf[0] = c0BdyFace[0].normal(oldPoints_);
-
-                xf[1] = c0BdyFace[1].centre(oldPoints_);
-                nf[1] = c0BdyFace[1].normal(oldPoints_);
-            }
-            else
-            if (c0BdyFace[1].which(original[0]) > -1)
-            {
-                xf[0] = c0BdyFace[1].centre(oldPoints_);
-                nf[0] = c0BdyFace[1].normal(oldPoints_);
-
-                xf[1] = c0BdyFace[0].centre(oldPoints_);
-                nf[1] = c0BdyFace[0].normal(oldPoints_);
-            }
-            else
-            {
-                FatalErrorIn
-                (
-                    "\n"
-                    "const changeMap "
-                    "dynamicTopoFvMesh::collapseQuadFace\n"
-                    "(\n"
-                    "    const label fIndex,\n"
-                    "    label overRideCase,\n"
-                    "    bool checkOnly\n"
-                    ")\n"
-                )   << "Could not find point in face."
-                    << endl;
-            }
-
-            // Compute edge-normals
-            ne[0] = (te[0] ^ nf[0]);
-            ne[1] = (te[1] ^ nf[1]);
-
-            ne[0] /= mag(ne[0]) + VSMALL;
-            ne[1] /= mag(ne[1]) + VSMALL;
-
-            // Reverse the vector, if necessary
-            if ((ne[0] & ne[1]) < 0.0)
-            {
-                ne[1] *= -1.0;
-            }
-
-            // Define modified old point-positions,
-            // with off-centering, if necessary
+            // Define old point-positions
             oldPoint[0] =
             (
-                oldPoints_[original[0]]
-              + (0.5 * te[0])
-              + (((0.05 * mag(te[0])) * ne[0]) * offCentre)
+                0.5 *
+                (
+                    oldPoints_[original[0]]
+                  + oldPoints_[replacement[0]]
+                )
             );
 
             oldPoint[1] =
             (
-                oldPoints_[original[1]]
-              + (0.5 * te[1])
-              + (((0.05 * mag(te[1])) * ne[1]) * offCentre)
+                0.5 *
+                (
+                    oldPoints_[original[1]]
+                  + oldPoints_[replacement[1]]
+                )
             );
 
             // Define check-points
@@ -483,7 +1299,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 "(\n"
                 "    const label fIndex,\n"
                 "    label overRideCase,\n"
-                "    bool checkOnly\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
                 ")\n"
             )
                 << "Edge: " << fIndex << ": " << faces_[fIndex]
@@ -512,6 +1329,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         (
             checkCollapse
             (
+                (*this),
                 hullTriFaces[indexI],
                 c0BdyIndex,
                 c1BdyIndex,
@@ -529,6 +1347,11 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         }
     }
 
+    // Add a map entry of the replacements as 'addedPoints'
+    //  - Used in coupled mapping
+    map.addPoint(replacement[0]);
+    map.addPoint(replacement[1]);
+
     // Are we only performing checks?
     if (checkOnly)
     {
@@ -536,13 +1359,15 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
         if (debug > 2)
         {
-            Info << "Face: " << fIndex
-                 << ":: " << faces_[fIndex] << nl
-                 << " collapseCase determined to be: "
-                 << collapseCase << nl
-                 << " Resulting quality: "
-                 << collapseQuality
-                 << endl;
+            Pout<< "Face: " << fIndex
+                << ":: " << faces_[fIndex] << nl
+                << " collapseCase determined to be: " << collapseCase << nl
+                << " Resulting quality: " << collapseQuality << nl
+                << " edgeBoundary: " << edgeBoundary << nl
+                << " nBoundCurves: " << nBoundCurves << nl
+                << " collapsePoints: " << original << nl
+                << " replacePoints: " << replacement << nl
+                << endl;
         }
 
         return map;
@@ -552,85 +1377,181 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     {
         const labelList& fE = faceEdges_[fIndex];
 
-        Info << nl << nl
-             << "Face: " << fIndex << ": " << faces_[fIndex] << nl
-             << "faceEdges: " << fE
-             << " is to be collapsed. " << endl;
+        Pout<< nl << nl
+            << "Face: " << fIndex << ": " << faces_[fIndex] << nl
+            << "faceEdges: " << fE << " is to be collapsed. "
+            << nl;
+
+        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichPatch(fIndex);
 
-        Info << "Patch: ";
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
 
         if (epIndex == -1)
         {
-            Info << "Internal" << endl;
+            Pout<< "Internal" << nl;
+        }
+        else
+        if (epIndex < boundary.size())
+        {
+            Pout<< boundary[epIndex].name() << nl;
         }
         else
         {
-            Info << boundaryMesh()[epIndex].name() << endl;
+            Pout<< " New patch: " << epIndex << endl;
         }
 
         if (debug > 2)
         {
-            Info << endl;
-            Info << "~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
-            Info << "Hulls before modification" << endl;
-            Info << "~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+            Pout<< nl
+                << "~~~~~~~~~~~~~~~~~~~~~~~~~" << nl
+                << "Hulls before modification" << nl
+                << "~~~~~~~~~~~~~~~~~~~~~~~~~" << nl;
 
-            Info << nl << "Cells belonging to first Edge Hull: "
-                 << hullCells[0] << endl;
+            if (debug > 3)
+            {
+                Pout<< "Cell [0] Boundary faces: " << nl
+                    << " Face: "<< c0BdyIndex[0]
+                    << "::" << c0BdyFace[0] << nl
+                    << " Face: "<< c0BdyIndex[1]
+                    << "::" << c0BdyFace[1] << nl;
+
+                Pout<< "Cell [0] Interior faces: " << nl
+                    << " Face: "<< c0IntIndex[0]
+                    << "::" << c0IntFace[0] << nl
+                    << " Face: "<< c0IntIndex[1]
+                    << "::" << c0IntFace[1] << nl;
+
+                if (c1 != -1)
+                {
+                    Pout<< "Cell [1] Boundary faces: " << nl
+                        << " Face: "<< c1BdyIndex[0]
+                        << "::" << c1BdyFace[0] << nl
+                        << " Face: "<< c1BdyIndex[1]
+                        << "::" << c1BdyFace[1] << nl;
+
+                    Pout<< "Cell [1] Interior faces: " << nl
+                        << " Face: "<< c1IntIndex[0]
+                        << "::" << c1IntFace[0] << nl
+                        << " Face: "<< c1IntIndex[1]
+                        << "::" << c1IntFace[1] << nl;
+                }
+            }
+
+            Pout<< nl << "Cells belonging to first Edge Hull: "
+                << hullCells[0] << nl;
 
             forAll(hullCells[0],cellI)
             {
                 const cell& firstCurCell = cells_[hullCells[0][cellI]];
 
-                Info << "Cell: " << hullCells[0][cellI]
-                     << ": " << firstCurCell << endl;
+                Pout<< "Cell: " << hullCells[0][cellI]
+                    << ": " << firstCurCell << nl;
 
                 forAll(firstCurCell,faceI)
                 {
-                    Info << firstCurCell[faceI]
-                         << ": " << faces_[firstCurCell[faceI]] << endl;
+                    Pout<< " Face: " << firstCurCell[faceI]
+                        << " : " << faces_[firstCurCell[faceI]]
+                        << " fE: " << faceEdges_[firstCurCell[faceI]]
+                        << nl;
+
+                    if (debug > 3)
+                    {
+                        const labelList& fE = faceEdges_[firstCurCell[faceI]];
+
+                        forAll(fE, edgeI)
+                        {
+                            Pout<< "  Edge: " << fE[edgeI]
+                                << " : " << edges_[fE[edgeI]]
+                                << nl;
+                        }
+                    }
                 }
             }
 
             const labelList& firstEdgeFaces = edgeFaces_[checkEdgeIndex[1]];
 
-            Info << nl << "First Edge Face Hull: "
-                 << firstEdgeFaces << endl;
+            Pout<< nl << "First Edge Face Hull: "
+                << firstEdgeFaces << nl;
 
             forAll(firstEdgeFaces,indexI)
             {
-                Info << firstEdgeFaces[indexI]
-                     << ": " << faces_[firstEdgeFaces[indexI]] << endl;
+                Pout<< " Face: " << firstEdgeFaces[indexI]
+                    << " : " << faces_[firstEdgeFaces[indexI]]
+                    << " fE: " << faceEdges_[firstEdgeFaces[indexI]]
+                    << nl;
+
+                if (debug > 3)
+                {
+                    const labelList& fE = faceEdges_[firstEdgeFaces[indexI]];
+
+                    forAll(fE, edgeI)
+                    {
+                        Pout<< "  Edge: " << fE[edgeI]
+                            << " : " << edges_[fE[edgeI]]
+                            << nl;
+                    }
+                }
             }
 
-            Info << nl << "Cells belonging to second Edge Hull: "
-                 << hullCells[1] << endl;
+            Pout<< nl << "Cells belonging to second Edge Hull: "
+                << hullCells[1] << nl;
 
             forAll(hullCells[1], cellI)
             {
                 const cell& secondCurCell = cells_[hullCells[1][cellI]];
 
-                Info << "Cell: " << hullCells[1][cellI]
-                     << ": " << secondCurCell << endl;
+                Pout<< "Cell: " << hullCells[1][cellI]
+                    << ": " << secondCurCell << nl;
 
                 forAll(secondCurCell, faceI)
                 {
-                    Info << secondCurCell[faceI]
-                         << ": " << faces_[secondCurCell[faceI]] << endl;
+                    Pout<< " Face: " << secondCurCell[faceI]
+                        << " : " << faces_[secondCurCell[faceI]]
+                        << " fE: " << faceEdges_[secondCurCell[faceI]]
+                        << nl;
+
+                    if (debug > 3)
+                    {
+                        const labelList& fE = faceEdges_[secondCurCell[faceI]];
+
+                        forAll(fE, edgeI)
+                        {
+                            Pout<< "  Edge: " << fE[edgeI]
+                                << " : " << edges_[fE[edgeI]]
+                                << nl;
+                        }
+                    }
                 }
             }
 
             const labelList& secondEdgeFaces = edgeFaces_[checkEdgeIndex[2]];
 
-            Info << nl << "Second Edge Face Hull: "
-                 << secondEdgeFaces << endl;
+            Pout<< nl << "Second Edge Face Hull: "
+                << secondEdgeFaces << nl;
 
             forAll(secondEdgeFaces, indexI)
             {
-                Info << secondEdgeFaces[indexI]
-                     << ": " << faces_[secondEdgeFaces[indexI]] << endl;
+                Pout<< " Face: " << secondEdgeFaces[indexI]
+                    << " : " << faces_[secondEdgeFaces[indexI]]
+                    << " fE: " << faceEdges_[secondEdgeFaces[indexI]]
+                    << nl;
+
+                if (debug > 3)
+                {
+                    const labelList& fE = faceEdges_[secondEdgeFaces[indexI]];
+
+                    forAll(fE, edgeI)
+                    {
+                        Pout<< "  Edge: " << fE[edgeI]
+                            << " : " << edges_[fE[edgeI]]
+                            << nl;
+                    }
+                }
             }
 
             // Write out VTK files prior to change
@@ -670,7 +1591,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     FixedList<label,4> edgeToKeep(-1), edgeToThrow(-1);
 
     // Maintain a list of modified faces for mapping
-    labelHashSet modifiedFaces;
+    DynamicList<label> modifiedFaces(10);
 
     // Case 2 & 3 use identical connectivity,
     // but different point locations
@@ -697,9 +1618,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             );
 
             // Add an entry for mapping
-            if (!modifiedFaces.found(firstEdgeFaces[faceI]))
+            if (findIndex(modifiedFaces, firstEdgeFaces[faceI]) == -1)
             {
-                modifiedFaces.insert(firstEdgeFaces[faceI]);
+                modifiedFaces.append(firstEdgeFaces[faceI]);
             }
 
             // Determine the quad-face in cell[0] & cell[1]
@@ -1005,6 +1926,11 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         removeEdge(checkEdgeIndex[1]);
         removeEdge(checkEdgeIndex[3]);
 
+        // Update map
+        map.removeEdge(checkEdgeIndex[0]);
+        map.removeEdge(checkEdgeIndex[1]);
+        map.removeEdge(checkEdgeIndex[2]);
+
         forAll(edgeToThrow, indexI)
         {
             if (edgeToThrow[indexI] == -1)
@@ -1013,11 +1939,18 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             }
 
             removeEdge(edgeToThrow[indexI]);
+
+            // Update map
+            map.removeEdge(edgeToThrow[indexI]);
         }
 
         // Delete the two points...
         removePoint(cv0);
         removePoint(cv1);
+
+        // Update map
+        map.removePoint(cv0);
+        map.removePoint(cv1);
     }
     else
     {
@@ -1042,9 +1975,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             );
 
             // Add an entry for mapping
-            if (!modifiedFaces.found(secondEdgeFaces[faceI]))
+            if (findIndex(modifiedFaces, secondEdgeFaces[faceI]) == -1)
             {
-                modifiedFaces.insert(secondEdgeFaces[faceI]);
+                modifiedFaces.append(secondEdgeFaces[faceI]);
             }
 
             // Determine the quad-face(s) in cell[0] & cell[1]
@@ -1350,6 +2283,11 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         removeEdge(checkEdgeIndex[2]);
         removeEdge(checkEdgeIndex[3]);
 
+        // Update map
+        map.removeEdge(checkEdgeIndex[0]);
+        map.removeEdge(checkEdgeIndex[2]);
+        map.removeEdge(checkEdgeIndex[3]);
+
         forAll(edgeToThrow, indexI)
         {
             if (edgeToThrow[indexI] == -1)
@@ -1358,102 +2296,117 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             }
 
             removeEdge(edgeToThrow[indexI]);
+
+            // Update map
+            map.removeEdge(edgeToThrow[indexI]);
         }
 
         // Delete the two points...
         removePoint(cv2);
         removePoint(cv3);
+
+        // Update map
+        map.removePoint(cv2);
+        map.removePoint(cv3);
     }
 
     if (debug > 2)
     {
-        Info << endl;
-        Info << "~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
-        Info << "Hulls after modification" << endl;
-        Info << "~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+        Pout<< nl
+            << "~~~~~~~~~~~~~~~~~~~~~~~~" << nl
+            << "Hulls after modification" << nl
+            << "~~~~~~~~~~~~~~~~~~~~~~~~" << nl;
 
-        Info << nl << "Cells belonging to first Edge Hull: "
-             << hullCells[0] << endl;
+        Pout<< nl << "Cells belonging to first Edge Hull: "
+            << hullCells[0] << nl;
 
         forAll(hullCells[0], cellI)
         {
             const cell& firstCurCell = cells_[hullCells[0][cellI]];
 
-            Info << "Cell: " << hullCells[0][cellI]
-                 << ": " << firstCurCell << endl;
+            Pout<< "Cell: " << hullCells[0][cellI]
+                << ": " << firstCurCell << nl;
 
             forAll(firstCurCell, faceI)
             {
-                Info << firstCurCell[faceI]
-                     << ": " << faces_[firstCurCell[faceI]] << endl;
+                Pout<< " Face: " << firstCurCell[faceI]
+                    << " : " << faces_[firstCurCell[faceI]]
+                    << " fE: " << faceEdges_[firstCurCell[faceI]]
+                    << nl;
             }
         }
 
         const labelList& firstEdgeFaces = edgeFaces_[checkEdgeIndex[1]];
 
-        Info << nl << "First Edge Face Hull: " << firstEdgeFaces << endl;
+        Pout<< nl << "First Edge Face Hull: " << firstEdgeFaces << nl;
 
         forAll(firstEdgeFaces, indexI)
         {
-            Info << firstEdgeFaces[indexI]
-                 << ": " << faces_[firstEdgeFaces[indexI]] << endl;
+            Pout<< " Face: " << firstEdgeFaces[indexI]
+                << " : " << faces_[firstEdgeFaces[indexI]]
+                << " fE: " << faceEdges_[firstEdgeFaces[indexI]]
+                << nl;
         }
 
-        Info << nl << "Cells belonging to second Edge Hull: "
-             << hullCells[1] << endl;
+        Pout<< nl << "Cells belonging to second Edge Hull: "
+            << hullCells[1] << nl;
 
         forAll(hullCells[1], cellI)
         {
             const cell& secondCurCell = cells_[hullCells[1][cellI]];
 
-            Info << "Cell: " << hullCells[1][cellI]
-                 << ": " << secondCurCell << endl;
+            Pout<< "Cell: " << hullCells[1][cellI]
+                << ": " << secondCurCell << nl;
 
             forAll(secondCurCell, faceI)
             {
-                Info << secondCurCell[faceI]
-                     << ": " << faces_[secondCurCell[faceI]] << endl;
+                Pout<< " Face: " << secondCurCell[faceI]
+                    << " : " << faces_[secondCurCell[faceI]]
+                    << " fE: " << faceEdges_[secondCurCell[faceI]]
+                    << nl;
             }
         }
 
         const labelList& secondEdgeFaces = edgeFaces_[checkEdgeIndex[2]];
 
-        Info << nl << "Second Edge Face Hull: " << secondEdgeFaces << endl;
+        Pout<< nl << "Second Edge Face Hull: " << secondEdgeFaces << nl;
 
         forAll(secondEdgeFaces, indexI)
         {
-            Info << secondEdgeFaces[indexI]
-                 << ": " << faces_[secondEdgeFaces[indexI]] << endl;
+            Pout<< " Face : " << secondEdgeFaces[indexI]
+                << " : " << faces_[secondEdgeFaces[indexI]]
+                << " fE: " << faceEdges_[secondEdgeFaces[indexI]]
+                << nl;
         }
 
-        Info << endl;
+        Pout<< "Retained face: "
+            << faceToKeep[0] << ": "
+            << " owner: " << owner_[faceToKeep[0]]
+            << " neighbour: " << neighbour_[faceToKeep[0]]
+            << nl;
 
-        Info << "Retained face: "
-             << faceToKeep[0] << ": "
-             << " owner: " << owner_[faceToKeep[0]]
-             << " neighbour: " << neighbour_[faceToKeep[0]]
-             << endl;
-
-        Info << "Discarded face: "
-             << faceToThrow[0] << ": "
-             << " owner: " << owner_[faceToThrow[0]]
-             << " neighbour: " << neighbour_[faceToThrow[0]]
-             << endl;
+        Pout<< "Discarded face: "
+            << faceToThrow[0] << ": "
+            << " owner: " << owner_[faceToThrow[0]]
+            << " neighbour: " << neighbour_[faceToThrow[0]]
+            << nl;
 
         if (c1 != -1)
         {
-            Info << "Retained face: "
-                 << faceToKeep[1] << ": "
-                 << " owner: " << owner_[faceToKeep[1]]
-                 << " neighbour: " << neighbour_[faceToKeep[1]]
-                 << endl;
+            Pout<< "Retained face: "
+                << faceToKeep[1] << ": "
+                << " owner: " << owner_[faceToKeep[1]]
+                << " neighbour: " << neighbour_[faceToKeep[1]]
+                << nl;
 
-            Info << "Discarded face: "
-                 << faceToThrow[1] << ": "
-                 << " owner: " << owner_[faceToThrow[1]]
-                 << " neighbour: " << neighbour_[faceToThrow[1]]
-                 << endl;
+            Pout<< "Discarded face: "
+                << faceToThrow[1] << ": "
+                << " owner: " << owner_[faceToThrow[1]]
+                << " neighbour: " << neighbour_[faceToThrow[1]]
+                << nl;
         }
+
+        Pout<< endl;
     }
 
     // Ensure proper orientation for the two retained faces
@@ -1636,6 +2589,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     if (owner_[faceToKeep[0]] == -1)
     {
         removeFace(faceToKeep[0]);
+
+        // Update map
+        map.removeFace(faceToKeep[0]);
     }
     else
     if
@@ -1664,10 +2620,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         );
 
         // Add an entry for mapping
-        if (!modifiedFaces.found(newFaceIndex))
-        {
-            modifiedFaces.insert(newFaceIndex);
-        }
+        modifiedFaces.append(newFaceIndex);
+
+        // Update map
+        map.addFace(newFaceIndex, labelList(1, faceToThrow[0]));
 
         // Add a faceEdges entry as well.
         // Edges don't have to change, since they're
@@ -1695,6 +2651,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         // Renumber the neighbour so that this face is removed correctly.
         neighbour_[faceToKeep[0]] = 0;
         removeFace(faceToKeep[0]);
+
+        // Update map
+        map.removeFace(faceToKeep[0]);
     }
 
     // Remove the unwanted faces in the cell(s) adjacent to this face,
@@ -1705,7 +2664,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     {
         if (cell_0[faceI] != fIndex && cell_0[faceI] != faceToKeep[0])
         {
-           removeFace(cell_0[faceI]);
+            removeFace(cell_0[faceI]);
+
+            // Update map
+            map.removeFace(cell_0[faceI]);
         }
     }
 
@@ -1722,6 +2684,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     // Remove the cell
     removeCell(c0);
 
+    // Update map
+    map.removeCell(c0);
+
     if (c1 == -1)
     {
         // Increment the surface-collapse counter
@@ -1733,6 +2698,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         if (owner_[faceToKeep[1]] == -1)
         {
             removeFace(faceToKeep[1]);
+
+            // Update map
+            map.removeFace(faceToKeep[1]);
         }
         else
         if
@@ -1761,10 +2729,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             );
 
             // Add an entry for mapping
-            if (!modifiedFaces.found(newFaceIndex))
-            {
-                modifiedFaces.insert(newFaceIndex);
-            }
+            modifiedFaces.append(newFaceIndex);
+
+            // Update map
+            map.addFace(newFaceIndex, labelList(1, faceToThrow[1]));
 
             // Add a faceEdges entry as well.
             // Edges don't have to change, since they're
@@ -1792,6 +2760,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             // Renumber the neighbour so that this face is removed correctly.
             neighbour_[faceToKeep[1]] = 0;
             removeFace(faceToKeep[1]);
+
+            // Update map
+            map.removeFace(faceToKeep[1]);
         }
 
         const cell& cell_1 = cells_[c1];
@@ -1800,7 +2771,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         {
             if (cell_1[faceI] != fIndex && cell_1[faceI] != faceToKeep[1])
             {
-               removeFace(cell_1[faceI]);
+                removeFace(cell_1[faceI]);
+
+                // Update map
+                map.removeFace(cell_1[faceI]);
             }
         }
 
@@ -1816,6 +2790,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
         // Remove the cell
         removeCell(c1);
+
+        // Update map
+        map.removeCell(c1);
     }
 
     // Move old / new points
@@ -1828,6 +2805,9 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     // Finally remove the face
     removeFace(fIndex);
 
+    // Update map
+    map.removeFace(fIndex);
+
     // Write out VTK files after change
     if (debug > 3)
     {
@@ -1867,23 +2847,6 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         );
     }
 
-    // Specify that an old point-position
-    // has been modified, if necessary
-    if (collapseCase == 3 && c1 > -1)
-    {
-        labelList mP(2, -1);
-
-        mP[0] = original[0];
-        mP[1] = replacement[0];
-
-        modPoints_.set(replacement[0], mP);
-
-        mP[0] = original[1];
-        mP[1] = replacement[1];
-
-        modPoints_.set(replacement[1], mP);
-    }
-
     // Fill-in candidate mapping information
     labelList mC(2, -1);
     mC[0] = c0, mC[1] = c1;
@@ -1908,28 +2871,30 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     }
 
     // Set face mapping information for modified faces
-    forAllConstIter(labelHashSet, modifiedFaces, fIter)
+    forAll(modifiedFaces, faceI)
     {
+        const label mfIndex = modifiedFaces[faceI];
+
         // Exclude deleted faces
-        if (faces_[fIter.key()].empty())
+        if (faces_[mfIndex].empty())
         {
             continue;
         }
 
         // Decide between default / weighted mapping
         // based on boundary information
-        label fPatch = whichPatch(fIter.key());
+        label fPatch = whichPatch(mfIndex);
 
         if (fPatch == -1)
         {
-            setFaceMapping(fIter.key());
+            setFaceMapping(mfIndex);
         }
         else
         {
             // Fill-in candidate mapping information
             labelList faceCandidates;
 
-            const labelList& fEdges = faceEdges_[fIter.key()];
+            const labelList& fEdges = faceEdges_[mfIndex];
 
             forAll(fEdges, edgeI)
             {
@@ -1942,7 +2907,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     {
                         if
                         (
-                            (eFaces[faceI] != fIter.key()) &&
+                            (eFaces[faceI] != mfIndex) &&
                             (whichPatch(eFaces[faceI]) == fPatch)
                         )
                         {
@@ -1957,7 +2922,600 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             }
 
             // Set the mapping for this face
-            setFaceMapping(fIter.key(), faceCandidates);
+            setFaceMapping(mfIndex, faceCandidates);
+        }
+    }
+
+    // If modification is coupled, update mapping info.
+    if (coupledModification_)
+    {
+        // Check if the collapse points are present
+        // on a processor not involved in the current
+        // operation, and update if necessary
+        if (procCouple && !localCouple)
+        {
+            forAll(procIndices_, pI)
+            {
+                bool involved = false;
+
+                forAll(slaveMaps, slaveI)
+                {
+                    // Alias for convenience...
+                    const changeMap& slaveMap = slaveMaps[slaveI];
+
+                    if (slaveMap.patchIndex() == pI && slaveMap.index() >= 0)
+                    {
+                        // Involved in this operation. Break out.
+                        involved = true;
+                        break;
+                    }
+                }
+
+                if (involved)
+                {
+                    continue;
+                }
+
+                // Check coupleMaps for point coupling
+                const label pointEnum = coupleMap::POINT;
+
+                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupleMap& cMap = recvMesh.map();
+
+                // Obtain non-const references
+                Map<label>& pointMap = cMap.entityMap(pointEnum);
+                Map<label>& rPointMap = cMap.reverseEntityMap(pointEnum);
+
+                label sI0 = -1, sI1 = -1;
+
+                if (collapsingSlave)
+                {
+                    if ((sI0 = cMap.findMaster(pointEnum, original[0])) > -1)
+                    {
+                        if (rPointMap.found(replacement[0]))
+                        {
+                            rPointMap[replacement[0]] = sI0;
+                        }
+                        else
+                        {
+                            rPointMap.insert(replacement[0], sI0);
+                        }
+
+                        pointMap[sI0] = replacement[0];
+                    }
+
+                    if ((sI1 = cMap.findMaster(pointEnum, original[1])) > -1)
+                    {
+                        if (rPointMap.found(replacement[1]))
+                        {
+                            rPointMap[replacement[1]] = sI1;
+                        }
+                        else
+                        {
+                            rPointMap.insert(replacement[1], sI1);
+                        }
+
+                        pointMap[sI1] = replacement[1];
+                    }
+                }
+                else
+                {
+                    if ((sI0 = cMap.findSlave(pointEnum, original[0])) > -1)
+                    {
+                        if (pointMap.found(replacement[0]))
+                        {
+                            pointMap[replacement[0]] = sI0;
+                        }
+                        else
+                        {
+                            pointMap.insert(replacement[0], sI0);
+                        }
+
+                        rPointMap[sI0] = replacement[0];
+                    }
+
+                    if ((sI1 = cMap.findSlave(pointEnum, original[1])) > -1)
+                    {
+                        if (pointMap.found(replacement[1]))
+                        {
+                            pointMap[replacement[1]] = sI1;
+                        }
+                        else
+                        {
+                            pointMap.insert(replacement[1], sI1);
+                        }
+
+                        rPointMap[sI1] = replacement[1];
+                    }
+                }
+
+                if (sI0 > -1 && sI1 > -1 && debug > 2)
+                {
+                    Pout<< " Found " << original[0] << " and " << original[1]
+                        << " on proc: " << procIndices_[pI]
+                        << endl;
+                }
+            }
+        }
+
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            const changeMap& slaveMap = slaveMaps[slaveI];
+
+            // Skip updates for edge-based coupling
+            if (slaveMap.index() < 0)
+            {
+                continue;
+            }
+
+            label pI = slaveMap.patchIndex();
+
+            // Fetch the appropriate coupleMap
+            const coupleMap* cMapPtr = NULL;
+
+            if (localCouple && !procCouple)
+            {
+                cMapPtr = &(patchCoupling_[pI].map());
+            }
+            else
+            if (procCouple && !localCouple)
+            {
+                cMapPtr = &(recvMeshes_[pI].map());
+            }
+
+            // Configure the slave replacement points.
+            //  - collapseQuadFace stores this as 'addedPoints'
+            label scP0 = slaveMap.removedPointList()[0];
+            label scP1 = slaveMap.removedPointList()[1];
+
+            label srP0 = slaveMap.addedPointList()[0].index();
+            label srP1 = slaveMap.addedPointList()[1].index();
+
+            // Alias for convenience
+            const coupleMap& cMap = *cMapPtr;
+
+            // Remove the point entries.
+            const label pointEnum = coupleMap::POINT;
+
+            // Obtain references
+            Map<label>& pointMap = cMap.entityMap(pointEnum);
+            Map<label>& rPointMap = cMap.reverseEntityMap(pointEnum);
+
+            if (collapsingSlave)
+            {
+                if (rPointMap[replacement[0]] == scP0)
+                {
+                    pointMap[srP0] = replacement[0];
+                    rPointMap[replacement[0]] = srP0;
+                }
+                else
+                if (rPointMap[replacement[0]] == scP1)
+                {
+                    pointMap[srP1] = replacement[0];
+                    rPointMap[replacement[0]] = srP1;
+                }
+
+                pointMap.erase(rPointMap[original[0]]);
+                rPointMap.erase(original[0]);
+            }
+            else
+            {
+                if (pointMap[replacement[0]] == scP0)
+                {
+                    rPointMap[srP0] = replacement[0];
+                    pointMap[replacement[0]] = srP0;
+                }
+                else
+                if (pointMap[replacement[0]] == scP1)
+                {
+                    rPointMap[srP1] = replacement[0];
+                    pointMap[replacement[0]] = srP1;
+                }
+
+                rPointMap.erase(pointMap[original[0]]);
+                pointMap.erase(original[0]);
+            }
+
+            if (collapsingSlave)
+            {
+                if (rPointMap[replacement[1]] == scP0)
+                {
+                    pointMap[srP0] = replacement[1];
+                    rPointMap[replacement[1]] = srP0;
+                }
+                else
+                if (rPointMap[replacement[1]] == scP1)
+                {
+                    pointMap[srP1] = replacement[1];
+                    rPointMap[replacement[1]] = srP1;
+                }
+
+                pointMap.erase(rPointMap[original[1]]);
+                rPointMap.erase(original[1]);
+            }
+            else
+            {
+                if (pointMap[replacement[1]] == scP0)
+                {
+                    rPointMap[srP0] = replacement[1];
+                    pointMap[replacement[1]] = srP0;
+                }
+                else
+                if (pointMap[replacement[1]] == scP1)
+                {
+                    rPointMap[srP1] = replacement[1];
+                    pointMap[replacement[1]] = srP1;
+                }
+
+                rPointMap.erase(pointMap[original[1]]);
+                pointMap.erase(original[1]);
+            }
+
+            // Remove the face entries
+            const label faceEnum = coupleMap::FACE;
+
+            // Obtain references
+            Map<label>& faceMap = cMap.entityMap(faceEnum);
+            Map<label>& rFaceMap = cMap.reverseEntityMap(faceEnum);
+
+            if (collapsingSlave)
+            {
+                faceMap.erase(faceMap[fIndex]);
+                rFaceMap.erase(fIndex);
+            }
+            else
+            {
+                rFaceMap.erase(faceMap[fIndex]);
+                faceMap.erase(fIndex);
+            }
+
+            // Configure a comparison face
+            face cFace(4);
+
+            // If any interior faces in the master map were
+            // converted to boundaries, account for it
+            const List<objectMap>& madF = map.addedFaceList();
+
+            forAll(madF, faceI)
+            {
+                label mfIndex = madF[faceI].index();
+                const face& mFace = faces_[mfIndex];
+
+                // Select appropriate mesh
+                const dynamicTopoFvMesh* meshPtr = NULL;
+
+                // Fetch the appropriate coupleMap
+                const coupleMap* crMapPtr = NULL;
+
+                // Fetch patch info
+                label ofPatch = whichPatch(fIndex);
+                label mfPatch = whichPatch(mfIndex);
+
+                if (localCouple && !procCouple)
+                {
+                    // Local coupling. Use this mesh itself
+                    meshPtr = this;
+                    crMapPtr = &(patchCoupling_[pI].map());
+                }
+                else
+                if (procCouple && !localCouple)
+                {
+                    // Occasionally, this face might talk to
+                    // a processor other than the slave
+                    if (ofPatch == mfPatch)
+                    {
+                        meshPtr = &(recvMeshes_[pI].subMesh());
+                        crMapPtr = &(recvMeshes_[pI].map());
+                    }
+                    else
+                    {
+                        label neiProcNo = getNeighbourProcessor(mfPatch);
+
+                        if (neiProcNo == -1)
+                        {
+                            // Not a processor patch. No mapping required.
+                            continue;
+                        }
+                        else
+                        {
+                            // Find an appropriate subMesh
+                            label prI = findIndex(procIndices_, neiProcNo);
+
+                            meshPtr = &(recvMeshes_[prI].subMesh());
+                            crMapPtr = &(recvMeshes_[prI].map());
+                        }
+                    }
+                }
+
+                bool matchedFace = false;
+
+                // Alias for convenience
+                const coupleMap& crMap = *crMapPtr;
+                const dynamicTopoFvMesh& sMesh = *meshPtr;
+
+                // Obtain references
+                Map<label>& pMap = crMap.entityMap(pointEnum);
+                Map<label>& fMap = crMap.entityMap(faceEnum);
+                Map<label>& rfMap = crMap.reverseEntityMap(faceEnum);
+
+                // Configure the face
+                forAll(cFace, pointI)
+                {
+                    cFace[pointI] =
+                    (
+                        pMap.found(mFace[pointI]) ?
+                        pMap[mFace[pointI]] : -1
+                    );
+                }
+
+                // Loop through all boundary faces on the subMesh
+                for
+                (
+                    label faceJ = sMesh.nOldInternalFaces_;
+                    faceJ < sMesh.faces_.size();
+                    faceJ++
+                )
+                {
+                    const face& sFace = sMesh.faces_[faceJ];
+
+                    if (face::compare(sFace, cFace))
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found face: " << faceJ
+                                << "::" << sFace
+                                << " with mfIndex: " << mfIndex
+                                << "::" << mFace
+                                << endl;
+                        }
+
+                        // Update faceMaps
+                        if (collapsingSlave)
+                        {
+                            if (fMap.found(faceJ))
+                            {
+                                fMap[faceJ] = mfIndex;
+                            }
+                            else
+                            {
+                                fMap.insert(faceJ, mfIndex);
+                            }
+
+                            if (rfMap.found(mfIndex))
+                            {
+                                rfMap[mfIndex] = faceJ;
+                            }
+                            else
+                            {
+                                rfMap.insert(mfIndex, faceJ);
+                            }
+                        }
+                        else
+                        {
+                            if (rfMap.found(faceJ))
+                            {
+                                rfMap[faceJ] = mfIndex;
+                            }
+                            else
+                            {
+                                rfMap.insert(faceJ, mfIndex);
+                            }
+
+                            if (fMap.found(mfIndex))
+                            {
+                                fMap[mfIndex] = faceJ;
+                            }
+                            else
+                            {
+                                fMap.insert(mfIndex, faceJ);
+                            }
+                        }
+
+                        matchedFace = true;
+
+                        break;
+                    }
+                }
+
+                if (!matchedFace)
+                {
+                    // Write out for post-processing
+                    writeVTK("masterFace_" + Foam::name(mfIndex), mfIndex, 2);
+
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "const changeMap "
+                        "dynamicTopoFvMesh::collapseQuadFace\n"
+                        "(\n"
+                        "    const label fIndex,\n"
+                        "    label overRideCase,\n"
+                        "    bool checkOnly,\n"
+                        "    bool forceOp\n"
+                        ")\n"
+                    )
+                        << " Master face: " << mfIndex
+                        << ": " << mFace << " could not be matched." << nl
+                        << " cFace: " << cFace << nl
+                        << abort(FatalError);
+                }
+            }
+
+            // If any interior faces in the slave map were
+            // converted to boundaries, account for it
+            const List<objectMap>& sadF = slaveMap.addedFaceList();
+
+            forAll(sadF, faceI)
+            {
+                label sIndex = slaveMap.index();
+                label sfIndex = sadF[faceI].index();
+
+                // Select appropriate mesh
+                const dynamicTopoFvMesh* meshPtr = NULL;
+
+                if (localCouple && !procCouple)
+                {
+                    // Local coupling. Use this mesh itself
+                    meshPtr = this;
+                }
+                else
+                if (procCouple && !localCouple)
+                {
+                    meshPtr = &(recvMeshes_[pI].subMesh());
+                }
+
+                // Alias for convenience
+                const dynamicTopoFvMesh& sMesh = *meshPtr;
+
+                label ofPatch = sMesh.whichPatch(sIndex);
+                label sfPatch = sMesh.whichPatch(sfIndex);
+
+                // Skip dissimilar patches
+                if (ofPatch != sfPatch)
+                {
+                    continue;
+                }
+
+                const face& sFace = sMesh.faces_[sfIndex];
+
+                forAll(cFace, pointI)
+                {
+                    cFace[pointI] =
+                    (
+                        rPointMap.found(sFace[pointI]) ?
+                        rPointMap[sFace[pointI]] : -1
+                    );
+                }
+
+                bool matchedFace = false;
+
+                // Loop through all boundary faces on this mesh
+                for
+                (
+                    label faceJ = nOldInternalFaces_;
+                    faceJ < faces_.size();
+                    faceJ++
+                )
+                {
+                    const face& mFace = faces_[faceJ];
+
+                    if (face::compare(mFace, cFace))
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found face: " << faceJ
+                                << "::" << mFace
+                                << " with sfIndex: " << sfIndex
+                                << "::" << sFace
+                                << endl;
+                        }
+
+                        // Update faceMaps
+                        if (collapsingSlave)
+                        {
+                            if (rFaceMap.found(faceJ))
+                            {
+                                rFaceMap[faceJ] = sfIndex;
+                            }
+                            else
+                            {
+                                rFaceMap.insert(faceJ, sfIndex);
+                            }
+
+                            if (faceMap.found(sfIndex))
+                            {
+                                faceMap[sfIndex] = faceJ;
+                            }
+                            else
+                            {
+                                faceMap.insert(sfIndex, faceJ);
+                            }
+                        }
+                        else
+                        {
+                            if (faceMap.found(faceJ))
+                            {
+                                faceMap[faceJ] = sfIndex;
+                            }
+                            else
+                            {
+                                faceMap.insert(faceJ, sfIndex);
+                            }
+
+                            if (rFaceMap.found(sfIndex))
+                            {
+                                rFaceMap[sfIndex] = faceJ;
+                            }
+                            else
+                            {
+                                rFaceMap.insert(sfIndex, faceJ);
+                            }
+                        }
+
+                        matchedFace = true;
+
+                        break;
+                    }
+                }
+
+                if (!matchedFace)
+                {
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "const changeMap "
+                        "dynamicTopoFvMesh::collapseQuadFace\n"
+                        "(\n"
+                        "    const label fIndex,\n"
+                        "    label overRideCase,\n"
+                        "    bool checkOnly,\n"
+                        "    bool forceOp\n"
+                        ")\n"
+                    )
+                        << " Slave face: " << sfIndex
+                        << ": " << sFace << " could not be matched." << nl
+                        << " cFace: " << cFace << nl
+                        << abort(FatalError);
+                }
+            }
+
+            // Push operation into coupleMap
+            switch (slaveMap.type())
+            {
+                case 1:
+                {
+                    cMap.pushOperation
+                    (
+                        slaveMap.index(),
+                        coupleMap::COLLAPSE_FIRST
+                    );
+
+                    break;
+                }
+
+                case 2:
+                {
+                    cMap.pushOperation
+                    (
+                        slaveMap.index(),
+                        coupleMap::COLLAPSE_SECOND
+                    );
+
+                    break;
+                }
+
+                case 3:
+                {
+                    cMap.pushOperation
+                    (
+                        slaveMap.index(),
+                        coupleMap::COLLAPSE_MIDPOINT
+                    );
+
+                    break;
+                }
+            }
         }
     }
 
@@ -1979,16 +3537,17 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
 // Method for the collapse of an edge in 3D
 // - Returns a changeMap with a type specifying:
+//    -3: Collapse failed since edge was on a noRefinement patch.
 //    -1: Collapse failed since max number of topo-changes was reached.
 //     0: Collapse could not be performed.
 //     1: Collapsed to first node.
 //     2: Collapsed to second node.
-//     3: Collapsed to mid-point (default)
+//     3: Collapsed to mid-point (default).
 // - overRideCase is used to force a certain collapse configuration.
 //    -1: Use this value to let collapseEdge decide a case.
 //     1: Force collapse to first node.
 //     2: Force collapse to second node.
-//     3: Force collapse to mid-point
+//     3: Force collapse to mid-point.
 // - checkOnly performs a feasibility check and returns without modifications.
 // - forceOp to force the collapse.
 const changeMap dynamicTopoFvMesh::collapseEdge
@@ -2010,7 +3569,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     //      [6] Checks the orientation of faces connected to the retained
     //          vertices
     //      [7] Remove one of the vertices of the edge
-    //      Update faceEdges, edgeFaces and edgePoints information
+    //      Update faceEdges and edgeFaces information
 
     // For 2D meshes, perform face-collapse
     if (twoDMesh_)
@@ -2022,7 +3581,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     label tIndex = self();
 
     // Prepare the changeMaps
-    changeMap map, slaveMap;
+    changeMap map;
+    List<changeMap> slaveMaps;
+    bool collapsingSlave = false;
 
     if
     (
@@ -2037,9 +3598,18 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     }
 
     // Check if edgeRefinements are to be avoided on patch.
-    if (lengthEstimator().checkRefinementPatch(whichEdgePatch(eIndex)))
+    const labelList& eF = edgeFaces_[eIndex];
+
+    forAll(eF, fI)
     {
-        return map;
+        label fPatch = whichPatch(eF[fI]);
+
+        if (baseMesh_.lengthEstimator().checkRefinementPatch(fPatch))
+        {
+            map.type() = -3;
+
+            return map;
+        }
     }
 
     // Sanity check: Is the index legitimate?
@@ -2060,9 +3630,724 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             << abort(FatalError);
     }
 
+    // If coupled modification is set, and this is a
+    // master edge, collapse its slaves as well.
+    bool localCouple = false, procCouple = false;
+
+    if (coupledModification_)
+    {
+        const edge& eCheck = edges_[eIndex];
+
+        const label edgeEnum = coupleMap::EDGE;
+        const label pointEnum = coupleMap::POINT;
+
+        // Is this a locally coupled edge (either master or slave)?
+        if (locallyCoupledEntity(eIndex, true))
+        {
+            localCouple = true;
+            procCouple = false;
+        }
+        else
+        if (processorCoupledEntity(eIndex))
+        {
+            procCouple = true;
+            localCouple = false;
+        }
+
+        if (localCouple && !procCouple)
+        {
+            // Determine the slave index.
+            label sIndex = -1, pIndex = -1;
+
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                    if ((sIndex = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        break;
+                    }
+
+                    // The following bit happens only during the sliver
+                    // exudation process, since slave edges are
+                    // usually not added to the coupled edge-stack.
+                    if ((sIndex = cMap.findMaster(edgeEnum, eIndex)) > -1)
+                    {
+                        pIndex = patchI;
+
+                        // Notice that we are collapsing a slave edge first.
+                        collapsingSlave = true;
+
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Edge: " << eIndex << ": " << eCheck << nl
+                    << abort(FatalError);
+            }
+            else
+            {
+                // If we've found the slave, size up the list
+                meshOps::sizeUpList
+                (
+                    changeMap(),
+                    slaveMaps
+                );
+
+                // Save index and patch for posterity
+                slaveMaps[0].index() = sIndex;
+                slaveMaps[0].patchIndex() = pIndex;
+            }
+
+            if (debug > 1)
+            {
+                Pout<< nl << " >> Collapsing slave edge: " << sIndex
+                    << " for master edge: " << eIndex << endl;
+            }
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            // If this is a new entity, bail out for now.
+            // This will be handled at the next time-step.
+            if (eIndex >= nOldEdges_)
+            {
+                return map;
+            }
+
+            // Check slaves
+            forAll(procIndices_, pI)
+            {
+                // Fetch reference to subMeshes
+                const coupledInfo& sendMesh = sendMeshes_[pI];
+                const coupledInfo& recvMesh = recvMeshes_[pI];
+
+                const coupleMap& scMap = sendMesh.map();
+                const coupleMap& rcMap = recvMesh.map();
+
+                // If this edge was sent to a lower-ranked
+                // processor, skip it.
+                if (procIndices_[pI] < Pstream::myProcNo())
+                {
+                    if (scMap.reverseEntityMap(edgeEnum).found(eIndex))
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Edge: " << eIndex
+                                << "::" << eCheck
+                                << " was sent to proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+                }
+
+                label sIndex = -1;
+
+                if ((sIndex = rcMap.findSlave(edgeEnum, eIndex)) > -1)
+                {
+                    // Check if a lower-ranked processor is
+                    // handling this edge
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                        if (debug > 3)
+                        {
+                            Pout<< "Edge: " << eIndex
+                                << "::" << eCheck
+                                << " is handled by proc: "
+                                << procIndices_[pI]
+                                << ", so bailing out."
+                                << endl;
+                        }
+
+                        return map;
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Save index and patch for posterity
+                    slaveMaps[curIndex].index() = sIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+                }
+                else
+                if
+                (
+                    (rcMap.findSlave(pointEnum, eCheck[0]) > -1) ||
+                    (rcMap.findSlave(pointEnum, eCheck[1]) > -1)
+                )
+                {
+                    // A point-only coupling exists.
+
+                    // Check if a lower-ranked processor is
+                    // handling this edge
+                    if (procIndices_[pI] < Pstream::myProcNo())
+                    {
+                         if (debug > 3)
+                         {
+                             Pout<< "Edge point on: " << eIndex
+                                 << "::" << eCheck
+                                 << " is handled by proc: "
+                                 << procIndices_[pI]
+                                 << ", so bailing out."
+                                 << endl;
+                         }
+
+                         return map;
+                    }
+
+                    label p0Index = rcMap.findSlave(pointEnum, eCheck[0]);
+                    label p1Index = rcMap.findSlave(pointEnum, eCheck[1]);
+
+                    if (p0Index > -1 && p1Index == -1)
+                    {
+                        sIndex = p0Index;
+                    }
+                    else
+                    if (p0Index == -1 && p1Index > -1)
+                    {
+                        sIndex = p1Index;
+                    }
+
+                    label curIndex = slaveMaps.size();
+
+                    // Size up the list
+                    meshOps::sizeUpList
+                    (
+                        changeMap(),
+                        slaveMaps
+                    );
+
+                    // Save index and patch for posterity
+                    //  - Negate the index to signify point coupling
+                    slaveMaps[curIndex].index() = -sIndex;
+                    slaveMaps[curIndex].patchIndex() = pI;
+                }
+            }
+        }
+        else
+        {
+            // Something's wrong with coupling maps
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    label overRideCase,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " localCouple: " << localCouple << nl
+                << " procCouple: " << procCouple << nl
+                << " Edge: " << eIndex << ": " << eCheck << nl
+                << abort(FatalError);
+        }
+
+        // Temporarily turn off coupledModification
+        unsetCoupledModification();
+
+        // Test the master edge for collapse, and decide on a case
+        changeMap masterMap = collapseEdge(eIndex, -1, true, forceOp);
+
+        // Turn it back on.
+        setCoupledModification();
+
+        // Master couldn't perform collapse
+        if (masterMap.type() <= 0)
+        {
+            return masterMap;
+        }
+
+        // For point-only coupling, define the points for checking
+        pointField slaveMoveNewPoint(slaveMaps.size(), vector::zero);
+        pointField slaveMoveOldPoint(slaveMaps.size(), vector::zero);
+
+        // Now check each of the slaves for collapse feasibility
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label slaveOverRide = -1;
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+
+            // If the edge is mapped onto itself, skip check
+            // (occurs for cyclic edges)
+            if ((sIndex == eIndex) && localCouple)
+            {
+                continue;
+            }
+
+            const coupleMap* cMapPtr = NULL;
+
+            edge mEdge(eCheck), sEdge(-1, -1);
+
+            if (localCouple)
+            {
+                sEdge = edges_[sIndex];
+
+                cMapPtr = &(patchCoupling_[pI].map());
+            }
+            else
+            if (procCouple)
+            {
+                const dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                cMapPtr = &(recvMeshes_[pI].map());
+
+                if (sIndex < 0)
+                {
+                    if (debug > 3)
+                    {
+                        Pout<< "Checking slave point: " << mag(sIndex)
+                            << "::" << sMesh.points_[mag(sIndex)]
+                            << " on proc: " << procIndices_[pI]
+                            << " for master edge: " << eIndex
+                            << " using collapseCase: " << masterMap.type()
+                            << endl;
+                    }
+                }
+                else
+                {
+                    sEdge = sMesh.edges_[sIndex];
+
+                    if (debug > 3)
+                    {
+                        Pout<< "Checking slave edge: " << sIndex
+                            << "::" << sMesh.edges_[sIndex]
+                            << " on proc: " << procIndices_[pI]
+                            << " for master edge: " << eIndex
+                            << " using collapseCase: " << masterMap.type()
+                            << endl;
+                    }
+                }
+            }
+
+            const Map<label>& pointMap = cMapPtr->entityMap(pointEnum);
+
+            // Perform a topological comparison.
+            switch (masterMap.type())
+            {
+                case 1:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI] = points_[mEdge[0]];
+                        slaveMoveOldPoint[slaveI] = oldPoints_[mEdge[0]];
+                    }
+                    else
+                    if (pointMap[mEdge[0]] == sEdge[0])
+                    {
+                        slaveOverRide = 1;
+                    }
+                    else
+                    if (pointMap[mEdge[1]] == sEdge[0])
+                    {
+                        slaveOverRide = 2;
+                    }
+                    else
+                    {
+                        // Write out for for post-processing
+                        writeVTK("mEdge_" + Foam::name(eIndex), eIndex, 1);
+
+                        FatalErrorIn
+                        (
+                            "\n"
+                            "const changeMap dynamicTopoFvMesh"
+                            "::collapseEdge\n"
+                            "(\n"
+                            "    const label eIndex,\n"
+                            "    label overRideCase,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Coupled collapse failed." << nl
+                            << "Master: " << eIndex << " : " << mEdge << nl
+                            << "Slave: " << sIndex << " : " << sEdge << nl
+                            << abort(FatalError);
+                    }
+
+                    break;
+                }
+
+                case 2:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI] = points_[mEdge[1]];
+                        slaveMoveOldPoint[slaveI] = oldPoints_[mEdge[1]];
+                    }
+                    else
+                    if (pointMap[mEdge[1]] == sEdge[1])
+                    {
+                        slaveOverRide = 2;
+                    }
+                    else
+                    if (pointMap[mEdge[0]] == sEdge[1])
+                    {
+                        slaveOverRide = 1;
+                    }
+                    else
+                    {
+                        // Write out for for post-processing
+                        writeVTK("mEdge_" + Foam::name(eIndex), eIndex, 1);
+
+                        FatalErrorIn
+                        (
+                            "\n"
+                            "const changeMap dynamicTopoFvMesh"
+                            "::collapseEdge\n"
+                            "(\n"
+                            "    const label eIndex,\n"
+                            "    label overRideCase,\n"
+                            "    bool checkOnly,\n"
+                            "    bool forceOp\n"
+                            ")\n"
+                        )
+                            << "Coupled collapse failed." << nl
+                            << "Master: " << eIndex << " : " << mEdge << nl
+                            << "Slave: " << sIndex << " : " << sEdge << nl
+                            << abort(FatalError);
+                    }
+
+                    break;
+                }
+
+                case 3:
+                {
+                    if (sIndex < 0)
+                    {
+                        slaveMoveNewPoint[slaveI] =
+                        (
+                            0.5 * (points_[mEdge[0]] + points_[mEdge[1]])
+                        );
+
+                        slaveMoveOldPoint[slaveI] =
+                        (
+                            0.5 * (oldPoints_[mEdge[0]] + oldPoints_[mEdge[1]])
+                        );
+                    }
+                    else
+                    {
+                        slaveOverRide = 3;
+                    }
+
+                    break;
+                }
+            }
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Test the slave edge
+            if (localCouple)
+            {
+                slaveMap = collapseEdge(sIndex, slaveOverRide, true, forceOp);
+            }
+            else
+            if (procCouple)
+            {
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                if (sIndex < 0)
+                {
+                    // Point-based coupling
+                    scalar slaveCollapseQuality(GREAT);
+                    DynamicList<label> cellsChecked(10);
+
+                    // Check cells connected to coupled point
+                    const labelList& pEdges = sMesh.pointEdges_[mag(sIndex)];
+
+                    bool infeasible = false;
+
+                    forAll(pEdges, edgeI)
+                    {
+                        const labelList& eFaces =
+                        (
+                            sMesh.edgeFaces_[pEdges[edgeI]]
+                        );
+
+                        // Build a list of cells to check
+                        forAll(eFaces, faceI)
+                        {
+                            label own = sMesh.owner_[eFaces[faceI]];
+                            label nei = sMesh.neighbour_[eFaces[faceI]];
+
+                            // Check owner cell
+                            if (findIndex(cellsChecked, own) == -1)
+                            {
+                                // Check if point movement is feasible
+                                if
+                                (
+                                    sMesh.checkCollapse
+                                    (
+                                        slaveMoveNewPoint[slaveI],
+                                        slaveMoveOldPoint[slaveI],
+                                        mag(sIndex),
+                                        own,
+                                        cellsChecked,
+                                        slaveCollapseQuality,
+                                        forceOp
+                                    )
+                                )
+                                {
+                                    infeasible = true;
+                                    break;
+                                }
+                            }
+
+                            if (nei == -1)
+                            {
+                                continue;
+                            }
+
+                            // Check neighbour cell
+                            if (findIndex(cellsChecked, nei) == -1)
+                            {
+                                // Check if point movement is feasible
+                                if
+                                (
+                                    sMesh.checkCollapse
+                                    (
+                                        slaveMoveNewPoint[slaveI],
+                                        slaveMoveOldPoint[slaveI],
+                                        mag(sIndex),
+                                        nei,
+                                        cellsChecked,
+                                        slaveCollapseQuality,
+                                        forceOp
+                                    )
+                                )
+                                {
+                                    infeasible = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (infeasible)
+                        {
+                            break;
+                        }
+                    }
+
+                    if (infeasible)
+                    {
+                        slaveMap.type() = 0;
+                    }
+                    else
+                    {
+                        slaveMap.type() = 1;
+                    }
+                }
+                else
+                {
+                    // Edge-based coupling
+                    slaveMap =
+                    (
+                        sMesh.collapseEdge
+                        (
+                            sIndex,
+                            slaveOverRide,
+                            true,
+                            forceOp
+                        )
+                    );
+                }
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            if (slaveMap.type() <= 0)
+            {
+                // Slave couldn't perform collapse.
+                map.type() = -2;
+
+                return map;
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
+        }
+
+        // Next collapse each slave edge (for real this time...)
+        forAll(slaveMaps, slaveI)
+        {
+            // Alias for convenience...
+            changeMap& slaveMap = slaveMaps[slaveI];
+
+            label sIndex = slaveMap.index();
+            label pI = slaveMap.patchIndex();
+
+            // If the edge is mapped onto itself, skip modification
+            // (occurs for cyclic edges)
+            if ((sIndex == eIndex) && localCouple)
+            {
+                continue;
+            }
+
+            label slaveOverRide = slaveMap.type();
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Collapse the slave
+            if (localCouple)
+            {
+                slaveMap = collapseEdge(sIndex, slaveOverRide, false, forceOp);
+            }
+            else
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                if (sIndex < 0)
+                {
+                    // Point based coupling
+
+                    // Move points to new location,
+                    // and update operation into coupleMap
+                    sMesh.points_[mag(sIndex)] = slaveMoveNewPoint[slaveI];
+                    sMesh.oldPoints_[mag(sIndex)] = slaveMoveOldPoint[slaveI];
+
+                    cMap.pushOperation
+                    (
+                        mag(sIndex),
+                        coupleMap::MOVE_POINT,
+                        slaveMoveNewPoint[slaveI],
+                        slaveMoveOldPoint[slaveI]
+                    );
+
+                    // Force operation to succeed
+                    slaveMap.type() = 1;
+                }
+                else
+                {
+                    // Edge-based coupling
+                    slaveMap =
+                    (
+                        sMesh.collapseEdge
+                        (
+                            sIndex,
+                            slaveOverRide,
+                            false,
+                            forceOp
+                        )
+                    );
+
+                    // Push operation into coupleMap
+                    switch (slaveMap.type())
+                    {
+                        case 1:
+                        {
+                            cMap.pushOperation
+                            (
+                                sIndex,
+                                coupleMap::COLLAPSE_FIRST
+                            );
+
+                            break;
+                        }
+
+                        case 2:
+                        {
+                            cMap.pushOperation
+                            (
+                                sIndex,
+                                coupleMap::COLLAPSE_SECOND
+                            );
+
+                            break;
+                        }
+
+                        case 3:
+                        {
+                            cMap.pushOperation
+                            (
+                                sIndex,
+                                coupleMap::COLLAPSE_MIDPOINT
+                            );
+
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Turn it back on.
+            setCoupledModification();
+
+            // The final operation has to succeed.
+            if (slaveMap.type() <= 0)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "Coupled topo-change for slave failed." << nl
+                    << " Edge: " << eIndex << ": " << eCheck << nl
+                    << " Slave index: " << sIndex << nl
+                    << " Patch index: " << pI << nl
+                    << " Type: " << slaveMap.type() << nl
+                    << abort(FatalError);
+            }
+
+            // Save index and patch for posterity
+            slaveMap.index() = sIndex;
+            slaveMap.patchIndex() = pI;
+        }
+    }
+
+    // Build hullVertices for this edge
+    labelList vertexHull;
+    buildVertexHull(eIndex, vertexHull);
+
     // Hull variables
     bool found = false;
-    label replaceIndex = -1, m = edgePoints_[eIndex].size();
+    label replaceIndex = -1, m = vertexHull.size();
 
     // Size up the hull lists
     labelList cellHull(m, -1);
@@ -2081,7 +4366,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         neighbour_,
         faceEdges_,
         edgeFaces_,
-        edgePoints_,
+        vertexHull,
         edgeHull,
         faceHull,
         cellHull,
@@ -2089,8 +4374,8 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     );
 
     // Check whether points of the edge lies on a boundary
-    FixedList<label, 2> nBoundCurves(0), checkPoints(-1);
     const FixedList<bool,2> edgeBoundary = checkEdgeBoundary(eIndex);
+    FixedList<label, 2> nBoundCurves(0), nProcCurves(0), checkPoints(-1);
 
     // Decide on collapseCase
     label collapseCase = -1;
@@ -2110,7 +4395,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         // If this is an interior edge with two boundary points.
         // Bail out for now. If proximity based refinement is
         // switched on, mesh may be sliced at this point.
-        if (whichEdgePatch(eIndex) == -1)
+        label edgePatch = whichEdgePatch(eIndex);
+
+        if (edgePatch == -1)
         {
             return map;
         }
@@ -2118,33 +4405,83 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         // Check if either point lies on a bounding curve
         // Used to ensure that collapses happen towards bounding curves.
         // If the edge itself is on a bounding curve, collapse is valid.
-        forAll(edges_[eIndex], pointI)
+        const edge& edgeCheck = edges_[eIndex];
+
+        forAll(edgeCheck, pointI)
         {
-            const labelList& pEdges = pointEdges_[edges_[eIndex][pointI]];
+            const labelList& pEdges = pointEdges_[edgeCheck[pointI]];
 
             forAll(pEdges, edgeI)
             {
-                if (checkBoundingCurve(pEdges[edgeI]))
+                if
+                (
+                    checkBoundingCurve
+                    (
+                        pEdges[edgeI],
+                        false,
+                        &(nProcCurves[pointI])
+                    )
+                )
                 {
                     nBoundCurves[pointI]++;
                 }
             }
         }
 
-        // Pick the point which is connected to more bounding curves
-        if (nBoundCurves[0] > nBoundCurves[1])
+        // Check for procCurves first
+        if (!coupledModification_ && !isSubMesh_)
         {
-            collapseCase = 1;
+            // Bail out for now
+            if (nProcCurves[0] && nProcCurves[1])
+            {
+                return map;
+            }
+
+            if (nProcCurves[0] && !nProcCurves[1])
+            {
+                if (nBoundCurves[1])
+                {
+                    // Bail out for now
+                    return map;
+                }
+                else
+                {
+                    collapseCase = 1;
+                }
+            }
+
+            if (!nProcCurves[0] && nProcCurves[1])
+            {
+                if (nBoundCurves[0])
+                {
+                    // Bail out for now
+                    return map;
+                }
+                else
+                {
+                    collapseCase = 2;
+                }
+            }
         }
-        else
-        if (nBoundCurves[1] > nBoundCurves[0])
+
+        // If still undecided, choose based on bounding curves
+        if (collapseCase == -1)
         {
-            collapseCase = 2;
-        }
-        else
-        {
-            // Bounding edge: collapseEdge can collapse this edge
-            collapseCase = 3;
+            // Pick the point which is connected to more bounding curves
+            if (nBoundCurves[0] > nBoundCurves[1])
+            {
+                collapseCase = 1;
+            }
+            else
+            if (nBoundCurves[1] > nBoundCurves[0])
+            {
+                collapseCase = 2;
+            }
+            else
+            {
+                // Bounding edge: collapseEdge can collapse this edge
+                collapseCase = 3;
+            }
         }
     }
     else
@@ -2252,7 +4589,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     // Also, keep track of resulting cell quality,
     // if collapse is indeed feasible
     scalar collapseQuality(GREAT);
-    labelHashSet cellsChecked;
+    DynamicList<label> cellsChecked(10);
 
     // Add all hull cells as 'checked',
     // and therefore, feasible
@@ -2263,7 +4600,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             continue;
         }
 
-        cellsChecked.insert(cellHull[cellI]);
+        cellsChecked.append(cellHull[cellI]);
     }
 
     // Check collapsibility of cells around edges
@@ -2288,7 +4625,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 label nei = neighbour_[eFaces[faceI]];
 
                 // Check owner cell
-                if (!cellsChecked.found(own))
+                if (findIndex(cellsChecked, own) == -1)
                 {
                     // Check if a collapse is feasible
                     if
@@ -2310,8 +4647,13 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     }
                 }
 
+                if (nei == -1)
+                {
+                    continue;
+                }
+
                 // Check neighbour cell
-                if (!cellsChecked.found(nei) && nei != -1)
+                if (findIndex(cellsChecked, nei) == -1)
                 {
                     // Check if a collapse is feasible
                     if
@@ -2336,31 +4678,34 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         }
     }
 
+    // Add a map entry of the replacePoint as an 'addedPoint'
+    //  - Used in coupled mapping
+    map.addPoint(replacePoint);
+
     // Are we only performing checks?
     if (checkOnly)
     {
+        // Return a succesful collapse possibility
         map.type() = collapseCase;
 
+        // Make note of the removed point
+        map.removePoint(collapsePoint);
+
         if (debug > 2)
         {
-            Info << "Edge: " << eIndex
-                 << ":: " << edges_[eIndex] << nl
-                 << " collapseCase determined to be: "
-                 << collapseCase << nl
-                 << " Resulting quality: "
-                 << collapseQuality
-                 << endl;
+            Pout<< nl << "Edge: " << eIndex
+                << ":: " << edges_[eIndex] << nl
+                << " collapseCase determined to be: " << collapseCase << nl
+                << " Resulting quality: " << collapseQuality << nl
+                << " collapsePoint: " << collapsePoint << nl
+                << " nBoundCurves: " << nBoundCurves << nl
+                << " nProcCurves: " << nProcCurves << nl
+                << endl;
         }
 
         return map;
     }
 
-    // Update number of surface collapses, if necessary.
-    if (whichEdgePatch(eIndex) > -1)
-    {
-        statistics_[6]++;
-    }
-
     // Define indices on the hull for removal / replacement
     label removeEdgeIndex = -1, replaceEdgeIndex = -1;
     label removeFaceIndex = -1, replaceFaceIndex = -1;
@@ -2401,39 +4746,48 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
     if (debug > 1)
     {
-        Info << nl << nl
-             << "Edge: " << eIndex
-             << ": " << edges_[eIndex]
-             << " is to be collapsed. " << endl;
+        Pout<< nl << nl
+            << "Edge: " << eIndex << ": " << edges_[eIndex]
+            << " is to be collapsed. " << nl;
+
+        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichEdgePatch(eIndex);
 
-        Info << "Patch: ";
+        const polyBoundaryMesh& boundary = boundaryMesh();
+
+        Pout<< " Patch: ";
 
         if (epIndex == -1)
         {
-            Info << "Internal" << endl;
+            Pout<< "Internal" << nl;
+        }
+        else
+        if (epIndex < boundary.size())
+        {
+            Pout<< boundary[epIndex].name() << nl;
         }
         else
         {
-            Info << boundaryMesh()[epIndex].name() << endl;
+            Pout<< " New patch: " << epIndex << endl;
         }
 
-        Info << " nBoundCurves: " << nBoundCurves << endl;
-        Info << " collapseCase: " << collapseCase << endl;
-
-        Info << " Resulting quality: " << collapseQuality << endl;
+        Pout<< " nBoundCurves: " << nBoundCurves << nl
+            << " nProcCurves: " << nProcCurves << nl
+            << " collapseCase: " << collapseCase << nl
+            << " Resulting quality: " << collapseQuality << endl;
 
         if (debug > 2)
         {
-            Info << "Vertices: " << edgePoints_[eIndex] << endl;
-            Info << "Edges: " << edgeHull << endl;
-            Info << "Faces: " << faceHull << endl;
-            Info << "Cells: " << cellHull << endl;
-            Info << "replacePoint: " << replacePoint << endl;
-            Info << "collapsePoint: " << collapsePoint << endl;
-            Info << "checkPoints: " << checkPoints << endl;;
-            Info << "ringEntities (removed faces): " << endl;
+            Pout<< " Edges: " << edgeHull << nl
+                << " Faces: " << faceHull << nl
+                << " Cells: " << cellHull << nl
+                << " replacePoint: " << replacePoint << nl
+                << " collapsePoint: " << collapsePoint << nl
+                << " checkPoints: " << checkPoints << nl;
+
+            Pout<< " ringEntities (removed faces): " << nl;
 
             forAll(ringEntities[removeFaceIndex], faceI)
             {
@@ -2444,10 +4798,11 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     continue;
                 }
 
-                Info << fIndex << ": " << faces_[fIndex] << endl;
+                Pout<< fIndex << ": " << faces_[fIndex] << nl;
             }
 
-            Info << "ringEntities (removed edges): " << endl;
+            Pout<< " ringEntities (removed edges): " << nl;
+
             forAll(ringEntities[removeEdgeIndex], edgeI)
             {
                 label ieIndex = ringEntities[removeEdgeIndex][edgeI];
@@ -2457,10 +4812,11 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     continue;
                 }
 
-                Info << ieIndex << ": " << edges_[ieIndex] << endl;
+                Pout<< ieIndex << ": " << edges_[ieIndex] << nl;
             }
 
-            Info << "ringEntities (replacement faces): " << endl;
+            Pout<< " ringEntities (replacement faces): " << nl;
+
             forAll(ringEntities[replaceFaceIndex], faceI)
             {
                 label fIndex = ringEntities[replaceFaceIndex][faceI];
@@ -2470,10 +4826,11 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     continue;
                 }
 
-                Info << fIndex << ": " << faces_[fIndex] << endl;
+                Pout<< fIndex << ": " << faces_[fIndex] << nl;
             }
 
-            Info << "ringEntities (replacement edges): " << endl;
+            Pout<< " ringEntities (replacement edges): " << nl;
+
             forAll(ringEntities[replaceEdgeIndex], edgeI)
             {
                 label ieIndex = ringEntities[replaceEdgeIndex][edgeI];
@@ -2483,39 +4840,45 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     continue;
                 }
 
-                Info << ieIndex << ": " << edges_[ieIndex] << endl;
+                Pout<< ieIndex << ": " << edges_[ieIndex] << nl;
             }
 
             labelList& collapsePointEdges = pointEdges_[collapsePoint];
 
-            Info << "pointEdges (collapsePoint): ";
+            Pout<< " pointEdges (collapsePoint): ";
 
             forAll(collapsePointEdges, edgeI)
             {
-                Info << collapsePointEdges[edgeI] << " ";
+                Pout<< collapsePointEdges[edgeI] << " ";
             }
 
-            Info << endl;
+            Pout<< nl;
 
             // Write out VTK files prior to change
+            //  - Using old-points for convenience in post-processing
             if (debug > 3)
             {
-                labelList vtkCells = cellsChecked.toc();
-
                 writeVTK
                 (
                     Foam::name(eIndex)
-                  + '(' + Foam::name(edges_[eIndex][0])
-                  + ',' + Foam::name(edges_[eIndex][1]) + ')'
+                  + '(' + Foam::name(collapsePoint)
+                  + ',' + Foam::name(replacePoint) + ')'
                   + "_Collapse_0",
-                    vtkCells
+                    cellsChecked,
+                    3, false, true
                 );
             }
         }
     }
 
+    if (whichEdgePatch(eIndex) > -1)
+    {
+        // Update number of surface collapses, if necessary.
+        statistics_[6]++;
+    }
+
     // Maintain a list of modified faces for mapping
-    labelHashSet modifiedFaces;
+    DynamicList<label> modifiedFaces(10);
 
     // Renumber all hull faces and edges
     forAll(faceHull, indexI)
@@ -2528,40 +4891,65 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         label replaceEdge = ringEntities[replaceEdgeIndex][indexI];
         label replaceFace = ringEntities[replaceFaceIndex][indexI];
 
-        const labelList& rmvEdgeFaces = edgeFaces_[edgeToRemove];
+        label replacePatch = whichEdgePatch(replaceEdge);
+        label removePatch = whichEdgePatch(edgeToRemove);
 
-        // Replace edgePoints for all edges emanating from hullVertices
-        // except ring-edges; those are sized-down later
-        const labelList& hullPointEdges =
-        (
-            pointEdges_[edgePoints_[eIndex][indexI]]
-        );
-
-        forAll(hullPointEdges, edgeI)
+        // Check if a patch conversion is necessary
+        if (replacePatch == -1 && removePatch > -1)
         {
-            if
+            if (debug > 2)
+            {
+                Pout<< " Edge: " << replaceEdge
+                    << " :: " << edges_[replaceEdge]
+                    << " is interior, but edge: " << edgeToRemove
+                    << " :: " << edges_[edgeToRemove]
+                    << " is on a boundary patch."
+                    << endl;
+            }
+
+            // Convert patch for edge
+            edge newEdge = edges_[replaceEdge];
+            labelList newEdgeFaces = edgeFaces_[replaceEdge];
+
+            // Insert the new edge
+            label newEdgeIndex =
             (
-                findIndex
+                insertEdge
                 (
-                    edgePoints_[hullPointEdges[edgeI]],
-                    collapsePoint
-                ) != -1
-             && findIndex
-                (
-                    edgePoints_[hullPointEdges[edgeI]],
-                    replacePoint
-                ) == -1
-            )
+                    removePatch,
+                    newEdge,
+                    newEdgeFaces
+                )
+            );
+
+            // Replace faceEdges for all
+            // connected faces.
+            forAll(newEdgeFaces, faceI)
             {
                 meshOps::replaceLabel
                 (
-                    collapsePoint,
-                    replacePoint,
-                    edgePoints_[hullPointEdges[edgeI]]
+                    replaceEdge,
+                    newEdgeIndex,
+                    faceEdges_[newEdgeFaces[faceI]]
                 );
             }
+
+            // Remove the edge
+            removeEdge(replaceEdge);
+
+            // Update map
+            map.removeEdge(replaceEdge);
+            map.addEdge(newEdgeIndex, labelList(1, replaceEdge));
+
+            // Replace index and patch
+            replaceEdge = newEdgeIndex;
+
+            // Modify ringEntities
+            ringEntities[replaceEdgeIndex][indexI] = newEdgeIndex;
         }
 
+        const labelList& rmvEdgeFaces = edgeFaces_[edgeToRemove];
+
         forAll(rmvEdgeFaces, faceI)
         {
             // Replace edge labels for faces
@@ -2578,20 +4966,13 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
             if ((replaceIndex = faceToCheck.which(collapsePoint)) > -1)
             {
-                if (debug > 2)
-                {
-                    Info << "Renumbering face: "
-                         << rmvEdgeFaces[faceI] << ": "
-                         << faceToCheck << endl;
-                }
-
                 // Renumber the face...
                 faces_[rmvEdgeFaces[faceI]][replaceIndex] = replacePoint;
 
                 // Add an entry for mapping
-                if (!modifiedFaces.found(rmvEdgeFaces[faceI]))
+                if (findIndex(modifiedFaces, rmvEdgeFaces[faceI]) == -1)
                 {
-                    modifiedFaces.insert(rmvEdgeFaces[faceI]);
+                    modifiedFaces.append(rmvEdgeFaces[faceI]);
                 }
             }
 
@@ -2648,13 +5029,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             edgeFaces_[edgeHull[indexI]]
         );
 
-        // Size down edgePoints for the ring edges
-        meshOps::sizeDownList
-        (
-            collapsePoint,
-            edgePoints_[edgeHull[indexI]]
-        );
-
         // Ensure proper orientation of retained faces
         if (owner_[faceToRemove] == cellToRemove)
         {
@@ -2699,10 +5073,10 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     );
 
                     // Set this face aside for mapping
-                    if (!modifiedFaces.found(newFaceIndex))
-                    {
-                        modifiedFaces.insert(newFaceIndex);
-                    }
+                    modifiedFaces.append(newFaceIndex);
+
+                    // Update map.
+                    map.addFace(newFaceIndex, labelList(1, faceToRemove));
 
                     // Ensure that all edges of this face are
                     // on the boundary.
@@ -2712,7 +5086,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         {
                             edge newEdge = edges_[newFE[edgeI]];
                             labelList newEF = edgeFaces_[newFE[edgeI]];
-                            labelList newEP = edgePoints_[newFE[edgeI]];
 
                             // Need patch information for the new edge.
                             // Find the corresponding edge in ringEntities.
@@ -2742,8 +5115,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 (
                                     repIndex,
                                     newEdge,
-                                    newEF,
-                                    newEP
+                                    newEF
                                 )
                             );
 
@@ -2762,6 +5134,15 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                             // Remove the edge
                             removeEdge(newFE[edgeI]);
 
+                            // Update map
+                            map.removeEdge(newFE[edgeI]);
+
+                            map.addEdge
+                            (
+                                newEdgeIndex,
+                                labelList(1, newFE[edgeI])
+                            );
+
                             // Replace faceEdges with new edge index
                             newFE[edgeI] = newEdgeIndex;
 
@@ -2789,6 +5170,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     // Remove the face
                     removeFace(replaceFace);
 
+                    // Update map
+                    map.removeFace(replaceFace);
+
                     // Replace label for the new owner
                     meshOps::replaceLabel
                     (
@@ -2824,6 +5208,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                             // This edge has to be removed entirely.
                             removeEdge(rmFE[edgeI]);
 
+                            // Update map
+                            map.removeEdge(rmFE[edgeI]);
+
                             label i =
                             (
                                 findIndex
@@ -2833,8 +5220,11 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 )
                             );
 
-                            // Modify ringEntities
-                            ringEntities[replaceEdgeIndex][i] = -1;
+                            if (i > -1)
+                            {
+                                // Modify ringEntities
+                                ringEntities[replaceEdgeIndex][i] = -1;
+                            }
                         }
                         else
                         {
@@ -2847,8 +5237,34 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         }
                     }
 
+                    // If this is a subMesh, and replaceFace is on
+                    // a physical boundary, make a 'special' entry
+                    // for coupled mapping purposes.
+                    if (isSubMesh_)
+                    {
+                        label kfPatch = whichPatch(replaceFace);
+                        label rfPatch = whichPatch(faceToRemove);
+
+                        if
+                        (
+                            (getNeighbourProcessor(rfPatch) > -1) &&
+                            (getNeighbourProcessor(kfPatch) == -1)
+                        )
+                        {
+                            map.addFace
+                            (
+                                faceToRemove,
+                                labelList(1, (-2 - kfPatch))
+                            );
+                        }
+                    }
+
+                    // Remove the face
                     removeFace(replaceFace);
 
+                    // Update map
+                    map.removeFace(replaceFace);
+
                     // Modify ringEntities and replaceFace
                     replaceFace = -1;
                     ringEntities[replaceFaceIndex][indexI] = -1;
@@ -2881,10 +5297,10 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 );
 
                 // Set this face aside for mapping
-                if (!modifiedFaces.found(newFaceIndex))
-                {
-                    modifiedFaces.insert(newFaceIndex);
-                }
+                modifiedFaces.append(newFaceIndex);
+
+                // Update map
+                map.addFace(newFaceIndex, labelList(1, faceToRemove));
 
                 // Ensure that all edges of this face are
                 // on the boundary.
@@ -2894,7 +5310,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     {
                         edge newEdge = edges_[newFE[edgeI]];
                         labelList newEF = edgeFaces_[newFE[edgeI]];
-                        labelList newEP = edgePoints_[newFE[edgeI]];
 
                         // Need patch information for the new edge.
                         // Find the corresponding edge in ringEntities.
@@ -2924,8 +5339,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                             (
                                 repIndex,
                                 newEdge,
-                                newEF,
-                                newEP
+                                newEF
                             )
                         );
 
@@ -2944,6 +5358,15 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         // Remove the edge
                         removeEdge(newFE[edgeI]);
 
+                        // Update map
+                        map.removeEdge(newFE[edgeI]);
+
+                        map.addEdge
+                        (
+                            newEdgeIndex,
+                            labelList(1, newFE[edgeI])
+                        );
+
                         // Replace faceEdges with new edge index
                         newFE[edgeI] = newEdgeIndex;
 
@@ -2971,6 +5394,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 // Remove the face
                 removeFace(replaceFace);
 
+                // Update map
+                map.removeFace(replaceFace);
+
                 // Replace label for the new owner
                 meshOps::replaceLabel
                 (
@@ -3047,15 +5473,27 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             // Remove faceToRemove and associated faceEdges
             removeFace(faceToRemove);
 
+            // Update map
+            map.removeFace(faceToRemove);
+
             // Remove the hull cell
             removeCell(cellToRemove);
+
+            // Update map
+            map.removeCell(cellToRemove);
         }
 
         // Remove the hull edge and associated edgeFaces
         removeEdge(edgeToRemove);
 
+        // Update map
+        map.removeEdge(edgeToRemove);
+
         // Remove the hull face
         removeFace(faceHull[indexI]);
+
+        // Update map
+        map.removeFace(faceHull[indexI]);
     }
 
     // Loop through pointEdges for the collapsePoint,
@@ -3070,13 +5508,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
         if (edgeIndex != eIndex)
         {
-            if (debug > 2)
-            {
-                Info << "Renumbering [edge]: "
-                     << edgeIndex << ": "
-                     << edges_[edgeIndex] << endl;
-            }
-
             if (edges_[edgeIndex][0] == collapsePoint)
             {
                 edges_[edgeIndex][0] = replacePoint;
@@ -3128,158 +5559,194 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
                 if ((replaceIndex = faceToCheck.which(collapsePoint)) > -1)
                 {
-                    if (debug > 2)
-                    {
-                        Info << "Renumbering face: "
-                             << eFaces[faceI] << ": "
-                             << faceToCheck << endl;
-                    }
-
                     // Renumber the face...
                     faces_[eFaces[faceI]][replaceIndex] = replacePoint;
 
                     // Set this face aside for mapping
-                    if (!modifiedFaces.found(eFaces[faceI]))
+                    if (findIndex(modifiedFaces, eFaces[faceI]) == -1)
                     {
-                        modifiedFaces.insert(eFaces[faceI]);
+                        modifiedFaces.append(eFaces[faceI]);
                     }
-
-                    // Look for an edge on this face that doesn't
-                    // contain collapsePoint or replacePoint.
-                    label rplIndex = -1;
-                    const labelList& fEdges = faceEdges_[eFaces[faceI]];
-
-                    forAll(fEdges, edgeI)
-                    {
-                        const edge& eCheck = edges_[fEdges[edgeI]];
-
-                        if
-                        (
-                            eCheck[0] != collapsePoint
-                         && eCheck[1] != collapsePoint
-                         && eCheck[0] != replacePoint
-                         && eCheck[1] != replacePoint
-                        )
-                        {
-                            rplIndex = fEdges[edgeI];
-                            break;
-                        }
-                    }
-
-                    // Modify edgePoints for this edge
-                    meshOps::replaceLabel
-                    (
-                        collapsePoint,
-                        replacePoint,
-                        edgePoints_[rplIndex]
-                    );
                 }
             }
         }
     }
 
-    // At this point, edgePoints for the replacement edges are broken,
-    // but edgeFaces are consistent. So use this information to re-build
-    // edgePoints for all replacement edges.
-    forAll(ringEntities[replaceEdgeIndex], edgeI)
-    {
-        // If the ring edge was removed, don't bother.
-        if (ringEntities[replaceEdgeIndex][edgeI] == -1)
-        {
-            continue;
-        }
-
-        if (debug > 2)
-        {
-            Info << "Building edgePoints for edge: "
-                 << ringEntities[replaceEdgeIndex][edgeI] << ": "
-                 << edges_[ringEntities[replaceEdgeIndex][edgeI]]
-                 << endl;
-        }
-
-        buildEdgePoints(ringEntities[replaceEdgeIndex][edgeI]);
-    }
-
-    // Move old / new points
+    // Set old / new points
     oldPoints_[replacePoint] = oldPoint;
     points_[replacePoint] = newPoint;
 
     // Remove the collapse point
     removePoint(collapsePoint);
 
+    // Update map
+    map.removePoint(collapsePoint);
+
     // Remove the edge
     removeEdge(eIndex);
 
-    // For cell-mapping, exclude all hull-cells
-    forAll(cellHull, indexI)
+    // Update map
+    map.removeEdge(eIndex);
+
+    // Check for duplicate edges connected to the replacePoint
+    const labelList& rpEdges = pointEdges_[replacePoint];
+
+    DynamicList<label> mergeFaces(10);
+
+    forAll(rpEdges, edgeI)
     {
-        if (cellsChecked.found(cellHull[indexI]))
+        const edge& eCheckI = edges_[rpEdges[edgeI]];
+        const label vCheckI = eCheckI.otherVertex(replacePoint);
+
+        for (label edgeJ = edgeI + 1; edgeJ < rpEdges.size(); edgeJ++)
         {
-            cellsChecked.erase(cellHull[indexI]);
+            const edge& eCheckJ = edges_[rpEdges[edgeJ]];
+            const label vCheckJ = eCheckJ.otherVertex(replacePoint);
+
+            if (vCheckJ == vCheckI)
+            {
+                labelPair efCheck(rpEdges[edgeI], rpEdges[edgeJ]);
+
+                forAll(efCheck, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[efCheck[edgeI]];
+
+                    forAll(eF, faceI)
+                    {
+                        label patch = whichPatch(eF[faceI]);
+
+                        if (patch == -1)
+                        {
+                            continue;
+                        }
+
+                        if (findIndex(mergeFaces, eF[faceI]) == -1)
+                        {
+                            mergeFaces.append(eF[faceI]);
+                        }
+                    }
+                }
+
+                if (debug > 2)
+                {
+                    Pout<< " Found duplicate: " << eCheckI << nl
+                        << " Merge faces: " << mergeFaces << nl
+                        << endl;
+                }
+            }
         }
     }
 
-    labelList mapCells = cellsChecked.toc();
+    // Merge faces if necessary
+    if (mergeFaces.size())
+    {
+        mergeBoundaryFaces(mergeFaces);
+    }
+
+    // Check and remove edges with an empty edgeFaces list
+    const labelList& replaceEdges = ringEntities[replaceEdgeIndex];
+
+    forAll(replaceEdges, edgeI)
+    {
+        label replaceEdge = replaceEdges[edgeI];
+
+        // If the ring edge was removed, don't bother.
+        if (replaceEdge > -1)
+        {
+            // Account for merged edges as well
+            if (edgeFaces_[replaceEdge].empty())
+            {
+                // Is this edge truly removed? If not, remove it.
+                if (edges_[replaceEdge] != edge(-1, -1))
+                {
+                    if (debug > 2)
+                    {
+                        Pout<< " Edge: " << replaceEdge
+                            << " :: " << edges_[replaceEdge]
+                            << " has empty edgeFaces."
+                            << endl;
+                    }
+
+                    // Remove the edge
+                    removeEdge(replaceEdge);
+
+                    // Update map
+                    map.removeEdge(replaceEdge);
+                }
+            }
+        }
+    }
+
+    // For cell-mapping, exclude all hull-cells
+    forAll(cellsChecked, indexI)
+    {
+        if (cells_[cellsChecked[indexI]].empty())
+        {
+            cellsChecked[indexI] = -1;
+        }
+        else
+        if (findIndex(cellHull, cellsChecked[indexI]) > 0)
+        {
+            cellsChecked[indexI] = -1;
+        }
+    }
 
     // Write out VTK files after change
+    //  - Using old-points for convenience in post-processing
     if (debug > 3)
     {
         writeVTK
         (
             Foam::name(eIndex)
-          + '(' + Foam::name(edges_[eIndex][0])
-          + ',' + Foam::name(edges_[eIndex][1]) + ')'
+          + '(' + Foam::name(collapsePoint)
+          + ',' + Foam::name(replacePoint) + ')'
           + "_Collapse_1",
-            mapCells
+            cellsChecked,
+            3, false, true
         );
     }
 
-    // Specify that an old point-position
-    // has been modified, if necessary
-    if (collapseCase == 3)
-    {
-        labelList mP(2, -1);
-
-        mP[0] = collapsePoint;
-        mP[1] = replacePoint;
-
-        modPoints_.set(replacePoint, mP);
-    }
-
     // Now that all old / new cells possess correct connectivity,
     // compute mapping information.
-    forAll(mapCells, cellI)
+    forAll(cellsChecked, cellI)
     {
+        if (cellsChecked[cellI] < 0)
+        {
+            continue;
+        }
+
         // Fill-in candidate mapping information
-        labelList mC(1, mapCells[cellI]);
+        labelList mC(1, cellsChecked[cellI]);
 
         // Set the mapping for this cell
-        setCellMapping(mapCells[cellI], mC);
+        setCellMapping(cellsChecked[cellI], mC);
     }
 
     // Set face mapping information for modified faces
-    forAllConstIter(labelHashSet, modifiedFaces, fIter)
+    forAll(modifiedFaces, faceI)
     {
+        const label mfIndex = modifiedFaces[faceI];
+
         // Exclude deleted faces
-        if (faces_[fIter.key()].empty())
+        if (faces_[mfIndex].empty())
         {
             continue;
         }
 
         // Decide between default / weighted mapping
         // based on boundary information
-        label fPatch = whichPatch(fIter.key());
+        label fPatch = whichPatch(mfIndex);
 
         if (fPatch == -1)
         {
-            setFaceMapping(fIter.key());
+            setFaceMapping(mfIndex);
         }
         else
         {
             // Fill-in candidate mapping information
             labelList faceCandidates;
 
-            const labelList& fEdges = faceEdges_[fIter.key()];
+            const labelList& fEdges = faceEdges_[mfIndex];
 
             forAll(fEdges, edgeI)
             {
@@ -3292,7 +5759,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     {
                         if
                         (
-                            (eFaces[faceI] != fIter.key()) &&
+                            (eFaces[faceI] != mfIndex) &&
                             (whichPatch(eFaces[faceI]) == fPatch)
                         )
                         {
@@ -3307,7 +5774,1084 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             }
 
             // Set the mapping for this face
-            setFaceMapping(fIter.key(), faceCandidates);
+            setFaceMapping(mfIndex, faceCandidates);
+        }
+    }
+
+    // If modification is coupled, update mapping info.
+    if (coupledModification_)
+    {
+        // Build a list of boundary edges / faces for mapping
+        DynamicList<label> checkEdges(10), checkFaces(10);
+
+        const labelList& pEdges = pointEdges_[replacePoint];
+
+        forAll(pEdges, edgeI)
+        {
+            const labelList& eFaces = edgeFaces_[pEdges[edgeI]];
+
+            forAll(eFaces, faceI)
+            {
+                label fPatch = whichPatch(eFaces[faceI]);
+
+                if (localCouple && !procCouple)
+                {
+                    if (!locallyCoupledEntity(eFaces[faceI], true, false, true))
+                    {
+                        continue;
+                    }
+
+                    // Check for cyclics
+                    if (boundaryMesh()[fPatch].type() == "cyclic")
+                    {
+                        // Check if this is a master face
+                        const coupleMap& cM = patchCoupling_[fPatch].map();
+                        const Map<label>& fM = cM.entityMap(coupleMap::FACE);
+
+                        // Only add master faces
+                        // (belonging to the first half)
+                        if (!fM.found(eFaces[faceI]))
+                        {
+                            continue;
+                        }
+                    }
+                }
+                else
+                if (procCouple && !localCouple)
+                {
+                    if (getNeighbourProcessor(fPatch) == -1)
+                    {
+                        continue;
+                    }
+                }
+
+                // Add face and its edges for checking
+                if (findIndex(checkFaces, eFaces[faceI]) == -1)
+                {
+                    // Add this face
+                    checkFaces.append(eFaces[faceI]);
+
+                    const labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+                    forAll(fEdges, edgeJ)
+                    {
+                        if (findIndex(checkEdges, fEdges[edgeJ]) == -1)
+                        {
+                            checkEdges.append(fEdges[edgeJ]);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Output check entities
+        if (debug > 4)
+        {
+            writeVTK
+            (
+                "checkEdges_" + Foam::name(eIndex),
+                checkEdges, 1, false, true
+            );
+
+            writeVTK
+            (
+                "checkFaces_" + Foam::name(eIndex),
+                checkFaces, 2, false, true
+            );
+        }
+
+        if (localCouple && !procCouple)
+        {
+            // Alias for convenience...
+            const changeMap& slaveMap = slaveMaps[0];
+
+            const label pI = slaveMap.patchIndex();
+            const coupleMap& cMap = patchCoupling_[pI].map();
+
+            // Obtain references
+            Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+            Map<label>& rPointMap = cMap.reverseEntityMap(coupleMap::POINT);
+
+            const labelList& rpList = slaveMap.removedPointList();
+            const List<objectMap>& apList = slaveMap.addedPointList();
+
+            // Configure the slave replacement point.
+            //  - collapseEdge stores this as an 'addedPoint'
+            label scPoint = -1, srPoint = -1;
+
+            if ((slaveMap.index() == eIndex) && localCouple)
+            {
+                // Cyclic edge at axis
+                scPoint = collapsePoint;
+                srPoint = replacePoint;
+            }
+            else
+            {
+                scPoint = rpList[0];
+                srPoint = apList[0].index();
+            }
+
+            if (collapsingSlave)
+            {
+                if (rPointMap[replacePoint] == scPoint)
+                {
+                    pointMap[srPoint] = replacePoint;
+                    rPointMap[replacePoint] = srPoint;
+                }
+            }
+            else
+            {
+                if (pointMap[replacePoint] == scPoint)
+                {
+                    rPointMap[srPoint] = replacePoint;
+                    pointMap[replacePoint] = srPoint;
+                }
+            }
+
+            // Update face maps
+            const label faceEnum = coupleMap::FACE;
+
+            // Obtain references
+            Map<label>& faceMap = cMap.entityMap(faceEnum);
+            Map<label>& rFaceMap = cMap.reverseEntityMap(faceEnum);
+
+            forAll(checkFaces, faceI)
+            {
+                label mfIndex = checkFaces[faceI];
+                label mfPatch = whichPatch(mfIndex);
+
+                const face& mF = faces_[mfIndex];
+
+                triFace cF
+                (
+                    pointMap.found(mF[0]) ? pointMap[mF[0]] : -1,
+                    pointMap.found(mF[1]) ? pointMap[mF[1]] : -1,
+                    pointMap.found(mF[2]) ? pointMap[mF[2]] : -1
+                );
+
+                if (cF[0] == -1 || cF[1] == -1 || cF[2] == -1)
+                {
+                    writeVTK
+                    (
+                        "failedFace_"
+                      + Foam::name(mfIndex),
+                        mfIndex,
+                        2, false, true
+                    );
+
+                    Pout<< " Failed to configure face for: "
+                        << mfIndex << " :: " << faces_[mfIndex]
+                        << " using comparison face: " << cF
+                        << abort(FatalError);
+                }
+
+                bool matchedFace = false;
+
+                // Fetch edges connected to first slave point
+                const labelList& spEdges = pointEdges_[cF[0]];
+
+                forAll(spEdges, edgeJ)
+                {
+                    label seIndex = spEdges[edgeJ];
+
+                    if (whichEdgePatch(seIndex) == -1)
+                    {
+                        continue;
+                    }
+
+                    const labelList& seFaces = edgeFaces_[seIndex];
+
+                    forAll(seFaces, faceI)
+                    {
+                        label sfIndex = seFaces[faceI];
+
+                        if (whichPatch(sfIndex) == -1)
+                        {
+                            continue;
+                        }
+
+                        const face& sF = faces_[sfIndex];
+
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(sF[0], sF[1], sF[2]), cF
+                            )
+                        )
+                        {
+                            if (debug > 2)
+                            {
+                                word pN(boundaryMesh()[mfPatch].name());
+
+                                Pout<< " Found face: " << sfIndex
+                                    << " :: " << sF
+                                    << " with mfIndex: " << mfIndex
+                                    << " :: " << faces_[mfIndex]
+                                    << " Patch: " << pN
+                                    << endl;
+                            }
+
+                            if (rFaceMap.found(sfIndex))
+                            {
+                                rFaceMap[sfIndex] = mfIndex;
+                            }
+                            else
+                            {
+                                rFaceMap.insert(sfIndex, mfIndex);
+                            }
+
+                            if (faceMap.found(mfIndex))
+                            {
+                                faceMap[mfIndex] = sfIndex;
+                            }
+                            else
+                            {
+                                faceMap.insert(mfIndex, sfIndex);
+                            }
+
+                            matchedFace = true;
+
+                            break;
+                        }
+                    }
+
+                    if (matchedFace)
+                    {
+                        break;
+                    }
+                }
+
+                if (!matchedFace)
+                {
+                    writeVTK
+                    (
+                        "failedFacePoints_"
+                      + Foam::name(mfIndex),
+                        cF, 0, false, true
+                    );
+
+                    Pout<< " Failed to match face: "
+                        << mfIndex << " :: " << faces_[mfIndex]
+                        << " using comparison face: " << cF
+                        << abort(FatalError);
+                }
+            }
+
+            // Update edge maps
+            const label edgeEnum = coupleMap::EDGE;
+
+            // Obtain references
+            Map<label>& edgeMap = cMap.entityMap(edgeEnum);
+            Map<label>& rEdgeMap = cMap.reverseEntityMap(edgeEnum);
+
+            forAll(checkEdges, edgeI)
+            {
+                label meIndex = checkEdges[edgeI];
+
+                const edge& mE = edges_[meIndex];
+
+                edge cE
+                (
+                    pointMap.found(mE[0]) ? pointMap[mE[0]] : -1,
+                    pointMap.found(mE[1]) ? pointMap[mE[1]] : -1
+                );
+
+                if (cE[0] == -1 || cE[1] == -1)
+                {
+                    writeVTK
+                    (
+                        "failedEdge_"
+                      + Foam::name(meIndex),
+                        meIndex,
+                        1, false, true
+                    );
+
+                    Pout<< " Failed to configure edge for: "
+                        << meIndex << " :: " << edges_[meIndex]
+                        << " using comparison edge: " << cE
+                        << abort(FatalError);
+                }
+
+                bool matchedEdge = false;
+
+                // Fetch edges connected to first slave point
+                const labelList& spEdges = pointEdges_[cE[0]];
+
+                forAll(spEdges, edgeJ)
+                {
+                    label seIndex = spEdges[edgeJ];
+
+                    const edge& sE = edges_[seIndex];
+
+                    if (sE == cE)
+                    {
+                        if (debug > 2)
+                        {
+                            Pout<< " Found edge: " << seIndex
+                                << " :: " << sE
+                                << " with meIndex: " << meIndex
+                                << " :: " << edges_[meIndex]
+                                << endl;
+                        }
+
+                        // Update reverse map
+                        if (rEdgeMap.found(seIndex))
+                        {
+                            rEdgeMap[seIndex] = meIndex;
+                        }
+                        else
+                        {
+                            rEdgeMap.insert(seIndex, meIndex);
+                        }
+
+                        // Update map
+                        if (edgeMap.found(meIndex))
+                        {
+                            edgeMap[meIndex] = seIndex;
+                        }
+                        else
+                        {
+                            edgeMap.insert(meIndex, seIndex);
+                        }
+
+                        matchedEdge = true;
+
+                        break;
+                    }
+                }
+
+                if (!matchedEdge)
+                {
+                    writeVTK
+                    (
+                        "failedEdgePoints_"
+                      + Foam::name(meIndex),
+                        cE, 0, false, true
+                    );
+
+                    Pout<< " Failed to match edge: "
+                        << meIndex << " :: " << edges_[meIndex]
+                        << " using comparison edge: " << cE
+                        << abort(FatalError);
+                }
+            }
+        }
+        else
+        if (procCouple && !localCouple)
+        {
+            // Update point mapping
+            forAll(procIndices_, pI)
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+
+                // Obtain references
+                Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+                Map<label>& rPointMap = cMap.reverseEntityMap(coupleMap::POINT);
+
+                const changeMap* slaveMapPtr = NULL;
+                const label pointEnum = coupleMap::POINT;
+
+                forAll(slaveMaps, slaveI)
+                {
+                    const changeMap& slaveMap = slaveMaps[slaveI];
+
+                    if (slaveMap.patchIndex() == pI)
+                    {
+                        if (slaveMap.index() < 0)
+                        {
+                            // Point-coupling
+                            label sI = -1;
+
+                            if (collapsingSlave)
+                            {
+                                sI = cMap.findMaster(pointEnum, collapsePoint);
+
+                                if (sI > -1)
+                                {
+                                    if (rPointMap.found(replacePoint))
+                                    {
+                                        rPointMap[replacePoint] = sI;
+                                    }
+                                    else
+                                    {
+                                        rPointMap.insert(replacePoint, sI);
+                                    }
+
+                                    pointMap[sI] = replacePoint;
+                                }
+                            }
+                            else
+                            {
+                                sI = cMap.findSlave(pointEnum, collapsePoint);
+
+                                if (sI > -1)
+                                {
+                                    if (pointMap.found(replacePoint))
+                                    {
+                                        pointMap[replacePoint] = sI;
+                                    }
+                                    else
+                                    {
+                                        pointMap.insert(replacePoint, sI);
+                                    }
+
+                                    rPointMap[sI] = replacePoint;
+                                }
+                            }
+
+                            if (sI > -1 && debug > 2)
+                            {
+                                Pout<< " Found point: " << collapsePoint
+                                    << " on proc: " << procIndices_[pI]
+                                    << endl;
+                            }
+                        }
+                        else
+                        {
+                            // Edge-coupling. Fetch address for later.
+                            slaveMapPtr = &slaveMap;
+                            break;
+                        }
+                    }
+                }
+
+                if (slaveMapPtr)
+                {
+                    // Alias for convenience...
+                    const changeMap& slaveMap = *slaveMapPtr;
+
+                    const labelList& rpList = slaveMap.removedPointList();
+                    const List<objectMap>& apList = slaveMap.addedPointList();
+
+                    // Configure the slave replacement point.
+                    //  - collapseEdge stores this as an 'addedPoint'
+                    label scPoint = rpList[0];
+                    label srPoint = apList[0].index();
+
+                    if (collapsingSlave)
+                    {
+                        if (rPointMap[replacePoint] == scPoint)
+                        {
+                            pointMap[srPoint] = replacePoint;
+                            rPointMap[replacePoint] = srPoint;
+                        }
+
+                        pointMap.erase(rPointMap[collapsePoint]);
+                        rPointMap.erase(collapsePoint);
+                    }
+                    else
+                    {
+                        if (pointMap[replacePoint] == scPoint)
+                        {
+                            rPointMap[srPoint] = replacePoint;
+                            pointMap[replacePoint] = srPoint;
+                        }
+
+                        rPointMap.erase(pointMap[collapsePoint]);
+                        pointMap.erase(collapsePoint);
+                    }
+
+                    // If any other points were removed, update map
+                    for (label pointI = 1; pointI < rpList.size(); pointI++)
+                    {
+                        if (collapsingSlave)
+                        {
+                            if (pointMap.found(rpList[pointI]))
+                            {
+                                rPointMap.erase(pointMap[rpList[pointI]]);
+                                pointMap.erase(rpList[pointI]);
+                            }
+                        }
+                        else
+                        {
+                            if (rPointMap.found(rpList[pointI]))
+                            {
+                                if (debug > 2)
+                                {
+                                    Pout<< " Found removed point: "
+                                        << rpList[pointI]
+                                        << " on proc: " << procIndices_[pI]
+                                        << " for point on this proc: "
+                                        << rPointMap[rpList[pointI]]
+                                        << endl;
+                                }
+
+                                pointMap.erase(rPointMap[rpList[pointI]]);
+                                rPointMap.erase(rpList[pointI]);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Update face mapping
+            forAll(procIndices_, pI)
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                const dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                // Obtain point maps
+                Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+
+                // Update face maps
+                const label faceEnum = coupleMap::FACE;
+
+                // Obtain references
+                Map<label>& faceMap = cMap.entityMap(faceEnum);
+                Map<label>& rFaceMap = cMap.reverseEntityMap(faceEnum);
+
+                const changeMap* slaveMapPtr = NULL;
+
+                forAll(slaveMaps, slaveI)
+                {
+                    const changeMap& slaveMap = slaveMaps[slaveI];
+
+                    if (slaveMap.patchIndex() == pI)
+                    {
+                        if (slaveMap.index() < 0)
+                        {
+                            // Point-coupling
+                            continue;
+                        }
+
+                        // Edge-coupling. Fetch address for later.
+                        slaveMapPtr = &slaveMap;
+                        break;
+                    }
+                }
+
+                forAll(checkFaces, faceI)
+                {
+                    label mfIndex = checkFaces[faceI];
+
+                    const face& mF = faces_[mfIndex];
+
+                    // Skip checks if a conversion occurred,
+                    // and this face was removed as a result
+                    if (mF.empty())
+                    {
+                        continue;
+                    }
+
+                    label mfPatch = whichPatch(mfIndex);
+                    label neiProc = getNeighbourProcessor(mfPatch);
+
+                    triFace cF
+                    (
+                        pointMap.found(mF[0]) ? pointMap[mF[0]] : -1,
+                        pointMap.found(mF[1]) ? pointMap[mF[1]] : -1,
+                        pointMap.found(mF[2]) ? pointMap[mF[2]] : -1
+                    );
+
+                    // Check if a patch conversion is necessary
+                    label newPatch = -1;
+                    bool requireConversion = false, physConvert = false;
+
+                    // Skip mapping if all points were not found
+                    if (cF[0] == -1 || cF[1] == -1 || cF[2] == -1)
+                    {
+                        // Is this actually a non-processor patch?
+                        if (neiProc == -1)
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            physConvert = true;
+                        }
+                    }
+
+                    // Has this face been converted to a physical boundary?
+                    if (faceMap.found(mfIndex) && slaveMapPtr)
+                    {
+                        // Alias for convenience...
+                        const changeMap& sMap = *slaveMapPtr;
+                        const labelList& rfList = sMap.removedFaceList();
+                        const List<objectMap>& afList = sMap.addedFaceList();
+
+                        // Was the face removed by the slave?
+                        label sfIndex = faceMap[mfIndex];
+
+                        if (findIndex(rfList, sfIndex) > -1)
+                        {
+                            if (debug > 2)
+                            {
+                                Pout<< " Found removed face: " << sfIndex
+                                    << " with mfIndex: " << mfIndex
+                                    << " :: " << faces_[mfIndex]
+                                    << " on proc: " << procIndices_[pI]
+                                    << endl;
+                            }
+
+                            // Remove map entry
+                            rFaceMap.erase(sfIndex);
+                            faceMap.erase(mfIndex);
+                        }
+
+                        // Check added faces for special entries
+                        forAll(afList, indexI)
+                        {
+                            const objectMap& af = afList[indexI];
+
+                            label mo =
+                            (
+                                af.masterObjects().size() ?
+                                af.masterObjects()[0] : 0
+                            );
+
+                            // Back out the physical patch ID
+                            if ((af.index() == sfIndex) && (mo < 0))
+                            {
+                                newPatch = Foam::mag(mo + 2);
+                                requireConversion = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    // Was an appropriate physical patch found?
+                    if (physConvert && !requireConversion)
+                    {
+                        continue;
+                    }
+
+                    // Are we talking to a different processor?
+                    if (neiProc != procIndices_[pI])
+                    {
+                        // This face needs to be converted
+                        const polyBoundaryMesh& boundary = boundaryMesh();
+
+                        forAll(boundary, pi)
+                        {
+                            if (getNeighbourProcessor(pi) == procIndices_[pI])
+                            {
+                                newPatch = pi;
+                                requireConversion = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (requireConversion)
+                    {
+                        // Obtain a copy before adding the new face,
+                        // since the reference might become
+                        // invalid during list resizing.
+                        face newFace = faces_[mfIndex];
+                        label newOwn = owner_[mfIndex];
+                        labelList newFaceEdges = faceEdges_[mfIndex];
+
+                        label newFaceIndex =
+                        (
+                            insertFace
+                            (
+                                newPatch,
+                                newFace,
+                                newOwn,
+                                -1
+                            )
+                        );
+
+                        faceEdges_.append(newFaceEdges);
+
+                        meshOps::replaceLabel
+                        (
+                            mfIndex,
+                            newFaceIndex,
+                            cells_[newOwn]
+                        );
+
+                        // Correct edgeFaces with the new face label.
+                        forAll(newFaceEdges, edgeI)
+                        {
+                            meshOps::replaceLabel
+                            (
+                                mfIndex,
+                                newFaceIndex,
+                                edgeFaces_[newFaceEdges[edgeI]]
+                            );
+                        }
+
+                        // Finally remove the face
+                        removeFace(mfIndex);
+
+                        // Update map
+                        map.removeFace(mfIndex);
+                        map.addFace(newFaceIndex, labelList(1, mfIndex));
+
+                        // Replace index and patch
+                        mfIndex = newFaceIndex;
+                        mfPatch = newPatch;
+
+                        // If conversion was to a physical patch,
+                        // skip the remaining face mapping steps
+                        if (getNeighbourProcessor(newPatch) == -1)
+                        {
+                            continue;
+                        }
+
+                        // Fail for now
+                        Pout<< " Conversion required... "
+                            << " Face: " << newFace << " : "
+                            << newFace.centre(points_)
+                            << abort(FatalError);
+
+                        // Push a patch-conversion operation
+                        cMap.pushOperation
+                        (
+                            newFaceIndex,
+                            coupleMap::CONVERT_PATCH,
+                            newFace.centre(points_),
+                            newFace.centre(oldPoints_)
+                        );
+                    }
+
+                    bool matchedFace = false;
+
+                    // Fetch edges connected to first slave point
+                    const labelList& spEdges = sMesh.pointEdges_[cF[0]];
+
+                    forAll(spEdges, edgeJ)
+                    {
+                        label seIndex = spEdges[edgeJ];
+
+                        if (sMesh.whichEdgePatch(seIndex) == -1)
+                        {
+                            continue;
+                        }
+
+                        const labelList& seFaces = sMesh.edgeFaces_[seIndex];
+
+                        forAll(seFaces, faceI)
+                        {
+                            label sfIndex = seFaces[faceI];
+
+                            if (sMesh.whichPatch(sfIndex) == -1)
+                            {
+                                continue;
+                            }
+
+                            const face& sF = sMesh.faces_[sfIndex];
+
+                            if
+                            (
+                                triFace::compare
+                                (
+                                    triFace(sF[0], sF[1], sF[2]), cF
+                                )
+                            )
+                            {
+                                if (debug > 2)
+                                {
+                                    word pN(boundaryMesh()[mfPatch].name());
+
+                                    Pout<< " Found face: " << sfIndex
+                                        << " :: " << sF
+                                        << " with mfIndex: " << mfIndex
+                                        << " :: " << faces_[mfIndex]
+                                        << " on proc: " << procIndices_[pI]
+                                        << " Patch: " << pN
+                                        << endl;
+                                }
+
+                                if (rFaceMap.found(sfIndex))
+                                {
+                                    rFaceMap[sfIndex] = mfIndex;
+                                }
+                                else
+                                {
+                                    rFaceMap.insert(sfIndex, mfIndex);
+                                }
+
+                                if (faceMap.found(mfIndex))
+                                {
+                                    faceMap[mfIndex] = sfIndex;
+                                }
+                                else
+                                {
+                                    faceMap.insert(mfIndex, sfIndex);
+                                }
+
+                                matchedFace = true;
+
+                                break;
+                            }
+                        }
+
+                        if (matchedFace)
+                        {
+                            break;
+                        }
+                    }
+
+                    if (!matchedFace)
+                    {
+                        sMesh.writeVTK
+                        (
+                            "failedFacePoints_"
+                          + Foam::name(mfIndex),
+                            cF, 0, false, true
+                        );
+
+                        Pout<< " Failed to match face: "
+                            << mfIndex << " :: " << faces_[mfIndex]
+                            << " using comparison face: " << cF
+                            << " on proc: " << procIndices_[pI]
+                            << abort(FatalError);
+                    }
+                }
+            }
+
+            // Update edge mapping
+            forAll(procIndices_, pI)
+            {
+                const coupleMap& cMap = recvMeshes_[pI].map();
+                const dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+                // Obtain point maps
+                Map<label>& pointMap = cMap.entityMap(coupleMap::POINT);
+
+                // Update edge maps
+                const label edgeEnum = coupleMap::EDGE;
+
+                // Obtain references
+                Map<label>& edgeMap = cMap.entityMap(edgeEnum);
+                Map<label>& rEdgeMap = cMap.reverseEntityMap(edgeEnum);
+
+                const changeMap* slaveMapPtr = NULL;
+
+                forAll(slaveMaps, slaveI)
+                {
+                    const changeMap& slaveMap = slaveMaps[slaveI];
+
+                    if (slaveMap.patchIndex() == pI)
+                    {
+                        if (slaveMap.index() < 0)
+                        {
+                            // Point-coupling
+                            continue;
+                        }
+
+                        // Edge-coupling. Fetch address for later.
+                        slaveMapPtr = &slaveMap;
+                        break;
+                    }
+                }
+
+                forAll(checkEdges, edgeI)
+                {
+                    label meIndex = checkEdges[edgeI];
+
+                    const edge& mE = edges_[meIndex];
+
+                    // Skip checks if a conversion occurred,
+                    // and this edge was removed as a result
+                    if (edgeFaces_[meIndex].empty())
+                    {
+                        continue;
+                    }
+
+                    label mePatch = whichEdgePatch(meIndex);
+                    label neiProc = getNeighbourProcessor(mePatch);
+
+                    edge cE
+                    (
+                        pointMap.found(mE[0]) ? pointMap[mE[0]] : -1,
+                        pointMap.found(mE[1]) ? pointMap[mE[1]] : -1
+                    );
+
+                    // Check if a patch conversion is necessary
+                    label newPatch = -1;
+                    bool requireConversion = true, physConvert = false;
+
+                    // Skip mapping if all points were not found
+                    if (cE[0] == -1 || cE[1] == -1)
+                    {
+                        // Is this actually a non-processor patch?
+                        if (neiProc == -1)
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            physConvert = true;
+                        }
+                    }
+
+                    // Has this edge been converted to a physical boundary?
+                    const labelList& meFaces = edgeFaces_[meIndex];
+
+                    forAll(meFaces, faceI)
+                    {
+                        label mfPatch = whichPatch(meFaces[faceI]);
+
+                        if (mfPatch == -1)
+                        {
+                            continue;
+                        }
+
+                        if (getNeighbourProcessor(mfPatch) == -1)
+                        {
+                            // Store physical patch for conversion
+                            newPatch = mfPatch;
+                        }
+                        else
+                        {
+                            requireConversion = false;
+                        }
+                    }
+
+                    // Was an appropriate physical patch found?
+                    if (physConvert && !requireConversion)
+                    {
+                        continue;
+                    }
+
+                    if (requireConversion)
+                    {
+                        edge newEdge = edges_[meIndex];
+                        labelList newEdgeFaces = edgeFaces_[meIndex];
+
+                        // Insert the new edge
+                        label newEdgeIndex =
+                        (
+                            insertEdge
+                            (
+                                newPatch,
+                                newEdge,
+                                newEdgeFaces
+                            )
+                        );
+
+                        // Replace faceEdges for all
+                        // connected faces.
+                        forAll(newEdgeFaces, faceI)
+                        {
+                            meshOps::replaceLabel
+                            (
+                                meIndex,
+                                newEdgeIndex,
+                                faceEdges_[newEdgeFaces[faceI]]
+                            );
+                        }
+
+                        // Remove the edge
+                        removeEdge(meIndex);
+
+                        // Update map
+                        map.removeEdge(meIndex);
+                        map.addEdge(newEdgeIndex, labelList(1, meIndex));
+
+                        // Replace index and patch
+                        meIndex = newEdgeIndex;
+                        mePatch = newPatch;
+
+                        // If conversion was to a physical patch,
+                        // skip the remaining face mapping steps
+                        if (getNeighbourProcessor(newPatch) == -1)
+                        {
+                            continue;
+                        }
+                    }
+
+                    bool matchedEdge = false;
+
+                    // Fetch edges connected to first slave point
+                    const labelList& spEdges = sMesh.pointEdges_[cE[0]];
+
+                    forAll(spEdges, edgeJ)
+                    {
+                        label seIndex = spEdges[edgeJ];
+
+                        const edge& sE = sMesh.edges_[seIndex];
+
+                        if (sE == cE)
+                        {
+                            if (debug > 2)
+                            {
+                                Pout<< " Found edge: " << seIndex
+                                    << " :: " << sE
+                                    << " with meIndex: " << meIndex
+                                    << " :: " << edges_[meIndex]
+                                    << " on proc: " << procIndices_[pI]
+                                    << endl;
+                            }
+
+                            // Update reverse map
+                            if (rEdgeMap.found(seIndex))
+                            {
+                                rEdgeMap[seIndex] = meIndex;
+                            }
+                            else
+                            {
+                                rEdgeMap.insert(seIndex, meIndex);
+                            }
+
+                            // Update map
+                            if (edgeMap.found(meIndex))
+                            {
+                                edgeMap[meIndex] = seIndex;
+                            }
+                            else
+                            {
+                                edgeMap.insert(meIndex, seIndex);
+                            }
+
+                            matchedEdge = true;
+
+                            break;
+                        }
+                    }
+
+                    if (!matchedEdge)
+                    {
+                        // Check if a coupling existed before
+                        if (edgeMap.found(meIndex) && slaveMapPtr)
+                        {
+                            // Alias for convenience...
+                            const changeMap& sMap = *slaveMapPtr;
+                            const labelList& reList = sMap.removedEdgeList();
+
+                            // Was the edge removed by the slave?
+                            if (findIndex(reList, edgeMap[meIndex]) > -1)
+                            {
+                                if (debug > 2)
+                                {
+                                    Pout<< " Found removed edge: "
+                                        << edgeMap[meIndex]
+                                        << " with meIndex: " << meIndex
+                                        << " :: " << edges_[meIndex]
+                                        << " on proc: " << procIndices_[pI]
+                                        << endl;
+                                }
+
+                                // Remove map entry
+                                rEdgeMap.erase(edgeMap[meIndex]);
+                                edgeMap.erase(meIndex);
+
+                                matchedEdge = true;
+                            }
+                        }
+                    }
+
+                    if (!matchedEdge)
+                    {
+                        sMesh.writeVTK
+                        (
+                            "failedEdgePoints_"
+                          + Foam::name(meIndex),
+                            cE, 0, false, true
+                        );
+
+                        Pout<< " Failed to match edge: "
+                            << meIndex << " :: " << edges_[meIndex]
+                            << " using comparison edge: " << cE
+                            << " on proc: " << procIndices_[pI]
+                            << abort(FatalError);
+                    }
+                }
+            }
         }
     }
 
@@ -3327,386 +6871,777 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 }
 
 
-// Remove the specified cells from the mesh,
-// and add internal faces/edges to the specified patch
-const changeMap dynamicTopoFvMesh::removeCells
+// Remove cell layer above specified patch
+const changeMap dynamicTopoFvMesh::removeCellLayer
 (
-    const labelList& cList,
-    const label patch
+    const label patchID
 )
 {
     changeMap map;
 
-    labelHashSet pointsToRemove, edgesToRemove, facesToRemove;
-    Map<label> facesToConvert, edgesToConvert;
+    labelHashSet edgesToRemove, facesToRemove;
+    Map<labelPair> pointsToRemove, edgesToKeep;
 
-    // First loop through all cells and accumulate
-    // a set of faces to be removed/converted.
-    forAll(cList, cellI)
+    DynamicList<label> patchFaces(patchSizes_[patchID]);
+    DynamicList<labelPair> cellsToRemove(patchSizes_[patchID]);
+    DynamicList<labelPair> hFacesToRemove(patchSizes_[patchID]);
+
+    for (label faceI = nOldInternalFaces_; faceI < faces_.size(); faceI++)
     {
-        const cell& cellToCheck = cells_[cList[cellI]];
+        label pIndex = whichPatch(faceI);
 
-        forAll(cellToCheck, faceI)
+        if (pIndex != patchID)
         {
-            label own = owner_[cellToCheck[faceI]];
-            label nei = neighbour_[cellToCheck[faceI]];
+            continue;
+        }
 
-            if (nei == -1)
-            {
-                if (!facesToRemove.found(cellToCheck[faceI]))
-                {
-                    facesToRemove.insert(cellToCheck[faceI]);
-                }
-            }
-            else
-            if
+        // Fetch owner cell
+        label cIndex = owner_[faceI];
+
+        // Add face to the list
+        patchFaces.append(faceI);
+
+        // Fetch appropriate face / cell
+        const face& bFace = faces_[faceI];
+        const cell& ownCell = cells_[cIndex];
+
+        // Get the opposing face from the cell
+        oppositeFace oFace = ownCell.opposingFace(faceI, faces_);
+
+        if (!oFace.found())
+        {
+            // Something's wrong here.
+            FatalErrorIn
             (
-                (findIndex(cList, own) != -1) &&
-                (findIndex(cList, nei) != -1)
+                "const changeMap dynamicTopoFvMesh::removeCellLayer"
+                "(const label patchID)"
             )
-            {
-                if (!facesToRemove.found(cellToCheck[faceI]))
-                {
-                    facesToRemove.insert(cellToCheck[faceI]);
-                }
-            }
-            else
-            {
-                facesToConvert.set(cellToCheck[faceI], -1);
-            }
+                << " Face: " << faceI << " :: " << bFace << nl
+                << " has no opposing face in cell: "
+                << cIndex << " :: " << ownCell << nl
+                << abort(FatalError);
         }
-    }
 
-    // Add all edges as candidates for conversion.
-    // Some of these will be removed altogether.
-    forAllConstIter(labelHashSet, facesToRemove, fIter)
-    {
-        const labelList& fEdges = faceEdges_[fIter.key()];
+        // Fetch cell on the other-side of the opposite face
+        label otherCellIndex =
+        (
+            (owner_[oFace.oppositeIndex()] == cIndex) ?
+            neighbour_[oFace.oppositeIndex()] :
+            owner_[oFace.oppositeIndex()]
+        );
+
+        if (otherCellIndex == -1)
+        {
+            // Opposite face is on a boundary, and layer
+            // removal would be invalid if we continued.
+            map.type() = -2;
+
+            return map;
+        }
+
+        // Fetch reference to other cell
+        const cell& otherCell = cells_[otherCellIndex];
+
+        // Find opposite face on the other cell
+        oppositeFace otFace =
+        (
+            otherCell.opposingFace
+            (
+                oFace.oppositeIndex(),
+                faces_
+            )
+        );
+
+        if (!otFace.found())
+        {
+            // Something's wrong here.
+            FatalErrorIn
+            (
+                "const changeMap dynamicTopoFvMesh::removeCellLayer"
+                "(const label patchID)"
+            )
+                << " Face: " << oFace.oppositeIndex()
+                << " :: " << oFace << nl
+                << " has no opposing face in cell: "
+                << otherCellIndex << " :: " << otherCell << nl
+                << abort(FatalError);
+        }
+
+        // All edges on the boundary face are to be retained
+        const labelList& fEdges = faceEdges_[faceI];
+        const labelList& ofEdges = faceEdges_[oFace.oppositeIndex()];
+        const labelList& otfEdges = faceEdges_[otFace.oppositeIndex()];
 
         forAll(fEdges, edgeI)
         {
-            if (whichEdgePatch(fEdges[edgeI]) == patch)
+            label eIndex = fEdges[edgeI];
+
+            if (!edgesToKeep.found(eIndex))
             {
-                // Make an identical map
-                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
-            }
-            else
-            {
-                edgesToConvert.set(fEdges[edgeI], -1);
-            }
-        }
-    }
+                // Find equivalent edge on opposite face
+                label oeIndex = -1, oteIndex = -1;
+                const edge& bEdge = edges_[eIndex];
 
-    forAllConstIter(Map<label>, facesToConvert, fIter)
-    {
-        const labelList& fEdges = faceEdges_[fIter.key()];
+                // Build edges for comparison
+                label startLoc = bFace.which(bEdge[0]);
+                label endLoc = bFace.which(bEdge[1]);
 
-        forAll(fEdges, edgeI)
-        {
-            if (whichEdgePatch(fEdges[edgeI]) == patch)
-            {
-                // Make an identical map
-                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
-            }
-            else
-            {
-                edgesToConvert.set(fEdges[edgeI], -1);
-            }
-        }
-    }
+                edge cEdge(oFace[startLoc], oFace[endLoc]);
+                edge ctEdge(otFace[startLoc], otFace[endLoc]);
 
-    // Build a list of edges to be removed.
-    forAllConstIter(Map<label>, edgesToConvert, eIter)
-    {
-        const labelList& eFaces = edgeFaces_[eIter.key()];
-
-        bool allRemove = true;
-
-        forAll(eFaces, faceI)
-        {
-            if (facesToConvert.found(eFaces[faceI]))
-            {
-                allRemove = false;
-                break;
-            }
-        }
-
-        if (allRemove)
-        {
-            if (!edgesToRemove.found(eIter.key()))
-            {
-                edgesToRemove.insert(eIter.key());
-            }
-        }
-    }
-
-    // Weed-out the conversion list.
-    forAllConstIter(labelHashSet, edgesToRemove, eIter)
-    {
-        edgesToConvert.erase(eIter.key());
-    }
-
-    // Build a set of points to be removed.
-    if (!twoDMesh_)
-    {
-        forAllConstIter(labelHashSet, edgesToRemove, eIter)
-        {
-            const edge& edgeToCheck = edges_[eIter.key()];
-
-            forAll(edgeToCheck, pointI)
-            {
-                const labelList& pEdges = pointEdges_[edgeToCheck[pointI]];
-
-                bool allRemove = true;
-
-                forAll(pEdges, edgeI)
+                forAll(ofEdges, edgeJ)
                 {
-                    if (!edgesToRemove.found(pEdges[edgeI]))
+                    const edge& ofEdge = edges_[ofEdges[edgeJ]];
+
+                    if (cEdge == ofEdge)
                     {
-                        allRemove = false;
+                        oeIndex = ofEdges[edgeJ];
                         break;
                     }
                 }
 
-                if (allRemove)
+                forAll(otfEdges, edgeJ)
                 {
-                    if (!pointsToRemove.found(edgeToCheck[pointI]))
+                    const edge& otfEdge = edges_[otfEdges[edgeJ]];
+
+                    if (ctEdge == otfEdge)
                     {
-                        pointsToRemove.insert(edgeToCheck[pointI]);
+                        oteIndex = otfEdges[edgeJ];
+                        break;
                     }
                 }
-            }
-        }
-    }
 
-    forAllIter(Map<label>, edgesToConvert, eIter)
-    {
-        const labelList& eFaces = edgeFaces_[eIter.key()];
-
-        label nConvFaces = 0;
-
-        forAll(eFaces, faceI)
-        {
-            if (facesToConvert.found(eFaces[faceI]))
-            {
-                nConvFaces++;
-            }
-        }
-
-        if (nConvFaces > 2)
-        {
-            Info << "Invalid conversion. Bailing out." << endl;
-            return map;
-        }
-    }
-
-    // Write out candidates for post-processing
-    if (debug > 2)
-    {
-        writeVTK("pointsToRemove", pointsToRemove.toc(), 0);
-        writeVTK("edgesToRemove", edgesToRemove.toc(), 1);
-        writeVTK("facesToRemove", facesToRemove.toc(), 2);
-        writeVTK("cellsToRemove", cList, 3);
-        writeVTK("edgesToConvert", edgesToConvert.toc(), 1);
-        writeVTK("facesToConvert", facesToConvert.toc(), 2);
-    }
-
-    // Loop through all faces for conversion, check orientation
-    // and create new faces in their place.
-    forAllIter(Map<label>, facesToConvert, fIter)
-    {
-        // Check if this internal face is oriented properly.
-        face newFace;
-        label newOwner = -1;
-        labelList fEdges = faceEdges_[fIter.key()];
-
-        if (findIndex(cList, neighbour_[fIter.key()]) != -1)
-        {
-            // Orientation is correct
-            newFace = faces_[fIter.key()];
-            newOwner = owner_[fIter.key()];
-        }
-        else
-        if (findIndex(cList, owner_[fIter.key()]) != -1)
-        {
-            // Face is to be reversed.
-            newFace = faces_[fIter.key()].reverseFace();
-            newOwner = neighbour_[fIter.key()];
-
-            setFlip(fIter.key());
-        }
-        else
-        {
-            // Something's terribly wrong
-            FatalErrorIn
-            (
-                "\n"
-                "const changeMap dynamicTopoFvMesh::removeCells\n"
-                "(\n"
-                "    const labelList& cList,\n"
-                "    const label patch\n"
-                ")\n"
-            )
-                << nl << " Invalid mesh. "
-                << abort(FatalError);
-        }
-
-        // Insert the reconfigured face at the boundary.
-        fIter() =
-        (
-            insertFace
-            (
-                patch,
-                newFace,
-                newOwner,
-                -1
-            )
-        );
-
-        // Add the faceEdges entry.
-        // Edges will be corrected later.
-        faceEdges_.append(fEdges);
-
-        // Add this face to the map.
-        map.addFace(fIter());
-
-        // Replace cell with the new face label
-        meshOps::replaceLabel
-        (
-            fIter.key(),
-            fIter(),
-            cells_[newOwner]
-        );
-
-        // Remove the internal face.
-        removeFace(fIter.key());
-    }
-
-    // Create a new edge for each converted edge
-    forAllIter(Map<label>, edgesToConvert, eIter)
-    {
-        if (eIter() == -1)
-        {
-            // Create copies before appending.
-            edge newEdge = edges_[eIter.key()];
-            labelList eFaces = edgeFaces_[eIter.key()];
-            labelList ePoints = edgePoints_[eIter.key()];
-
-            eIter() =
-            (
-                insertEdge
-                (
-                    patch,
-                    newEdge,
-                    eFaces,
-                    ePoints
-                )
-            );
-
-            // Add this edge to the map.
-            map.addEdge(eIter());
-
-            // Remove the edge
-            removeEdge(eIter.key());
-        }
-    }
-
-    // Loop through all faces for conversion, and replace edgeFaces.
-    forAllConstIter(Map<label>, facesToConvert, fIter)
-    {
-        // Make a copy, because this list is going to
-        // be modified within this loop.
-        labelList fEdges = faceEdges_[fIter()];
-
-        forAll(fEdges, edgeI)
-        {
-            if (edgesToConvert.found(fEdges[edgeI]))
-            {
-                meshOps::replaceLabel
-                (
-                    fIter.key(),
-                    fIter(),
-                    edgeFaces_[edgesToConvert[fEdges[edgeI]]]
-                );
-
-                meshOps::replaceLabel
-                (
-                    fEdges[edgeI],
-                    edgesToConvert[fEdges[edgeI]],
-                    faceEdges_[fIter()]
-                );
-            }
-        }
-    }
-
-    // Loop through all edges for conversion, and size-down edgeFaces.
-    forAllConstIter(Map<label>, edgesToConvert, eIter)
-    {
-        // Make a copy, because this list is going to
-        // be modified within this loop.
-        labelList eFaces = edgeFaces_[eIter()];
-
-        forAll(eFaces, faceI)
-        {
-            if (facesToRemove.found(eFaces[faceI]))
-            {
-                meshOps::sizeDownList
-                (
-                    eFaces[faceI],
-                    edgeFaces_[eIter()]
-                );
-            }
-
-            // Replace old edges with new ones.
-            labelList& fEdges = faceEdges_[eFaces[faceI]];
-
-            forAll(fEdges, edgeI)
-            {
-                if (edgesToConvert.found(fEdges[edgeI]))
+                if (oeIndex < 0 || oteIndex < 0)
                 {
-                    fEdges[edgeI] = edgesToConvert[fEdges[edgeI]];
+                    FatalErrorIn
+                    (
+                        "const changeMap dynamicTopoFvMesh::removeCellLayer"
+                        "(const label patchID)"
+                    )
+                        << " Could not find comparison edge: " << nl
+                        << " cEdge: " << cEdge
+                        << " oeIndex: " << oeIndex << nl
+                        << " ctEdge: " << ctEdge
+                        << " oteIndex: " << oteIndex << nl
+                        << " for edge: " << bEdge
+                        << abort(FatalError);
+                }
+
+                // Make entry
+                edgesToKeep.insert(eIndex, labelPair(oeIndex, oteIndex));
+            }
+        }
+
+        // Add information to removal lists
+        cellsToRemove.append
+        (
+            labelPair
+            (
+                cIndex,
+                otherCellIndex
+            )
+        );
+
+        hFacesToRemove.append
+        (
+            labelPair
+            (
+                oFace.oppositeIndex(),
+                otFace.oppositeIndex()
+            )
+        );
+
+        // Mark points for removal
+        forAll(oFace, pointI)
+        {
+            label pIndex = oFace[pointI];
+
+            if (!pointsToRemove.found(pIndex))
+            {
+                // Make entry
+                pointsToRemove.insert
+                (
+                    pIndex,
+                    labelPair(bFace[pointI], otFace[pointI])
+                );
+            }
+        }
+
+        // Loop through cell faces and mark
+        // faces / edges for removal
+        forAll(ownCell, faceJ)
+        {
+            label fIndex = ownCell[faceJ];
+
+            if (fIndex == faceI || fIndex == oFace.oppositeIndex())
+            {
+                continue;
+            }
+
+            if (!facesToRemove.found(fIndex))
+            {
+                facesToRemove.insert(fIndex);
+            }
+
+            const labelList& checkEdges = faceEdges_[fIndex];
+
+            forAll(checkEdges, edgeI)
+            {
+                label eIndex = checkEdges[edgeI];
+
+                if (edgesToKeep.found(eIndex))
+                {
+                    continue;
+                }
+
+                if (!edgesToRemove.found(eIndex))
+                {
+                    edgesToRemove.insert(eIndex);
                 }
             }
         }
     }
 
-    // At this point, edgeFaces is consistent.
-    // Correct edge-points for all converted edges
-    if (!twoDMesh_)
+    // Correct edgeFaces / faceEdges for retained edges
+    forAllConstIter(Map<labelPair>, edgesToKeep, eIter)
     {
-        forAllConstIter(Map<label>, edgesToConvert, eIter)
+        const labelList& rmeFaces = edgeFaces_[eIter().first()];
+
+        forAll(rmeFaces, faceI)
         {
-            buildEdgePoints(eIter());
+            labelList& fE = faceEdges_[rmeFaces[faceI]];
+
+            bool foundRp = (findIndex(fE, eIter.key()) > -1);
+            bool foundRn = (findIndex(fE, eIter().second()) > -1);
+
+            if (foundRp)
+            {
+                // Size-down edgeFaces for replacement
+                meshOps::sizeDownList
+                (
+                    rmeFaces[faceI],
+                    edgeFaces_[eIter.key()]
+                );
+            }
+
+            if (foundRn)
+            {
+                // Size-up edgeFaces for replacement
+                meshOps::sizeUpList
+                (
+                    rmeFaces[faceI],
+                    edgeFaces_[eIter.key()]
+                );
+
+                // Replace edge index
+                meshOps::replaceLabel
+                (
+                    eIter().first(),
+                    eIter.key(),
+                    fE
+                );
+            }
         }
     }
 
     // Remove unwanted faces
     forAllConstIter(labelHashSet, facesToRemove, fIter)
     {
+        // Remove the face
         removeFace(fIter.key());
+
+        // Update map
+        map.removeFace(fIter.key());
     }
 
     // Remove unwanted edges
     forAllConstIter(labelHashSet, edgesToRemove, eIter)
     {
+        // Remove the edge
         removeEdge(eIter.key());
+
+        // Update map
+        map.removeEdge(eIter.key());
     }
 
     // Remove unwanted points
-    forAllConstIter(labelHashSet, pointsToRemove, pIter)
+    forAllConstIter(Map<labelPair>, pointsToRemove, pIter)
     {
+        // Update pointEdges information first
+        if (!twoDMesh_)
+        {
+            const labelList& pEdges = pointEdges_[pIter.key()];
+
+            // Configure edge for comparison
+            edge cEdge
+            (
+                pIter.key(),
+                pIter().second()
+            );
+
+            label replaceEdge = -1;
+
+            forAll(pEdges, edgeI)
+            {
+                const edge& checkEdge = edges_[pEdges[edgeI]];
+
+                if (checkEdge == cEdge)
+                {
+                    replaceEdge = pEdges[edgeI];
+                    break;
+                }
+            }
+
+            if (replaceEdge == -1)
+            {
+                FatalErrorIn
+                (
+                    "const changeMap dynamicTopoFvMesh::removeCellLayer"
+                    "(const label patchID)"
+                )
+                    << " Could not find comparison edge: " << nl
+                    << " cEdge: " << cEdge
+                    << " for point: " << pIter.key() << nl
+                    << " pointEdges: " << pEdges
+                    << abort(FatalError);
+            }
+
+            // Size-up pointEdges
+            meshOps::sizeUpList
+            (
+                replaceEdge,
+                pointEdges_[pIter().first()]
+            );
+        }
+
+        // Remove the point
         removePoint(pIter.key());
+
+        // Update map
+        map.removePoint(pIter.key());
     }
 
+    // Track modified faces for mapping
+    labelHashSet modifiedFaces;
+
     // Remove all cells
-    forAll(cList, cellI)
+    forAll(cellsToRemove, indexI)
     {
-        removeCell(cList[cellI]);
+        // Replace face label on the other cell
+        meshOps::replaceLabel
+        (
+            hFacesToRemove[indexI].first(),
+            patchFaces[indexI],
+            cells_[cellsToRemove[indexI].second()]
+        );
+
+        // Set owner information
+        owner_[patchFaces[indexI]] = cellsToRemove[indexI].second();
+
+        // Replace points on faces / edges
+        const cell& otherCell = cells_[cellsToRemove[indexI].second()];
+
+        forAll(otherCell, faceI)
+        {
+            face& faceToCheck = faces_[otherCell[faceI]];
+
+            bool modified = false;
+
+            forAll(faceToCheck, pointI)
+            {
+                if (pointsToRemove.found(faceToCheck[pointI]))
+                {
+                    faceToCheck[pointI] =
+                    (
+                        pointsToRemove[faceToCheck[pointI]].first()
+                    );
+                }
+
+                modified = true;
+            }
+
+            // Add face to list
+            if (modified && !modifiedFaces.found(otherCell[faceI]))
+            {
+                modifiedFaces.insert(otherCell[faceI]);
+            }
+
+            const labelList& fEdges = faceEdges_[otherCell[faceI]];
+
+            forAll(fEdges, edgeI)
+            {
+                edge& edgeToCheck = edges_[fEdges[edgeI]];
+
+                if (pointsToRemove.found(edgeToCheck[0]))
+                {
+                    edgeToCheck[0] =
+                    (
+                        pointsToRemove[edgeToCheck[0]].first()
+                    );
+                }
+
+                if (pointsToRemove.found(edgeToCheck[1]))
+                {
+                    edgeToCheck[1] =
+                    (
+                        pointsToRemove[edgeToCheck[1]].first()
+                    );
+                }
+            }
+        }
+
+        // Remove horizontal interior face
+        removeFace(hFacesToRemove[indexI].first());
+
+        // Update map
+        map.removeFace(hFacesToRemove[indexI].first());
+
+        // Remove the cell
+        removeCell(cellsToRemove[indexI].first());
+
+        // Update map
+        map.removeCell(cellsToRemove[indexI].first());
+    }
+
+    // Now that all old / new cells possess correct connectivity,
+    // compute mapping information.
+    forAll(cellsToRemove, indexI)
+    {
+        // Set mapping for the modified cell
+        setCellMapping
+        (
+            cellsToRemove[indexI].second(),
+            cellsToRemove[indexI]
+        );
+    }
+
+    // Set face mapping information for modified faces
+    forAllConstIter(labelHashSet, modifiedFaces, fIter)
+    {
+        // Decide between default / weighted mapping
+        // based on boundary information
+        label fPatch = whichPatch(fIter.key());
+
+        if (fPatch == -1)
+        {
+            // Default mapping for interior faces
+            setFaceMapping(fIter.key());
+        }
+        else
+        {
+            // Map boundary face from itself
+            setFaceMapping(fIter.key(), labelList(1, fIter.key()));
+        }
     }
 
     // Set the flag
     topoChangeFlag_ = true;
 
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+
+// Merge a set of boundary faces into internal
+const changeMap dynamicTopoFvMesh::mergeBoundaryFaces
+(
+    const labelList& mergeFaces
+)
+{
+    changeMap map;
+
+    if (debug > 2)
+    {
+        Pout << "Merging faces: " << mergeFaces << endl;
+    }
+
+    List<labelPair> mergePairs(0);
+
+    forAll(mergeFaces, faceI)
+    {
+        const face& fI = faces_[mergeFaces[faceI]];
+
+        for (label faceJ = faceI + 1; faceJ < mergeFaces.size(); faceJ++)
+        {
+            const face& fJ = faces_[mergeFaces[faceJ]];
+
+            bool merge = false;
+
+            if (fI.size() == fJ.size() && fI.size() == 3)
+            {
+                if
+                (
+                    triFace::compare
+                    (
+                        triFace(fI[0], fI[1], fI[2]),
+                        triFace(fJ[0], fJ[1], fJ[2])
+                    )
+                )
+                {
+                    merge = true;
+                }
+            }
+            else
+            if (face::compare(fI, fJ))
+            {
+                merge = true;
+            }
+
+            if (merge)
+            {
+                meshOps::sizeUpList
+                (
+                    labelPair(mergeFaces[faceI], mergeFaces[faceJ]),
+                    mergePairs
+                );
+
+                break;
+            }
+        }
+    }
+
+    if (debug > 2)
+    {
+        Pout<< " mergePairs: " << mergePairs << endl;
+    }
+
+    DynamicList<label> checkEdges(10);
+
+    forAll(mergePairs, pairI)
+    {
+        label firstFace = mergePairs[pairI].first();
+        label secondFace = mergePairs[pairI].second();
+
+        // Obtain owners for both faces, and compare their labels
+        label newOwner = -1, newNeighbour = -1;
+        label removedFace = -1, retainedFace = -1;
+
+        if (owner_[firstFace] < owner_[secondFace])
+        {
+            // Retain the first face
+            removedFace = secondFace;
+            retainedFace = firstFace;
+
+            newOwner = owner_[firstFace];
+            newNeighbour = owner_[secondFace];
+        }
+        else
+        {
+            // Retain the second face
+            removedFace = firstFace;
+            retainedFace = secondFace;
+
+            newOwner = owner_[secondFace];
+            newNeighbour = owner_[firstFace];
+        }
+
+        // Insert a new interior face
+        label newFaceIndex =
+        (
+            insertFace
+            (
+                -1,
+                face(faces_[retainedFace]),
+                newOwner,
+                newNeighbour
+            )
+        );
+
+        // Add the faceEdges entry
+        faceEdges_.append(labelList(faceEdges_[retainedFace]));
+
+        // Update map
+        map.addFace(newFaceIndex);
+
+        // Replace cell with the new face label
+        meshOps::replaceLabel
+        (
+            removedFace,
+            newFaceIndex,
+            cells_[owner_[removedFace]]
+        );
+
+        meshOps::replaceLabel
+        (
+            retainedFace,
+            newFaceIndex,
+            cells_[owner_[retainedFace]]
+        );
+
+        const labelList& fEdges = faceEdges_[newFaceIndex];
+        const labelList& rfEdges = faceEdges_[removedFace];
+
+        // Check for common edges on the removed face
+        forAll(rfEdges, edgeI)
+        {
+            label reIndex = rfEdges[edgeI];
+
+            if (findIndex(fEdges, reIndex) == -1)
+            {
+                // Find the equivalent edge
+                const edge& rEdge = edges_[reIndex];
+                const labelList& reFaces = edgeFaces_[reIndex];
+
+                label keIndex = -1;
+
+                forAll(fEdges, edgeJ)
+                {
+                    if (edges_[fEdges[edgeJ]] == rEdge)
+                    {
+                        keIndex = fEdges[edgeJ];
+                        break;
+                    }
+                }
+
+                if (keIndex == -1)
+                {
+                    Pout<< " Could not find edge for: "
+                        << reIndex << " :: " << rEdge
+                        << abort(FatalError);
+                }
+
+                // Add edgeFaces from this edge
+                forAll(reFaces, faceI)
+                {
+                    if (reFaces[faceI] == removedFace)
+                    {
+                        continue;
+                    }
+
+                    meshOps::sizeUpList
+                    (
+                        reFaces[faceI],
+                        edgeFaces_[keIndex]
+                    );
+
+                    meshOps::replaceLabel
+                    (
+                        reIndex,
+                        keIndex,
+                        faceEdges_[reFaces[faceI]]
+                    );
+                }
+
+                // Remove the old edge
+                removeEdge(reIndex);
+
+                // Update map
+                map.removeEdge(reIndex);
+            }
+        }
+
+        // Replace edgeFaces with the new face label
+        forAll(fEdges, edgeI)
+        {
+            label eIndex = fEdges[edgeI];
+
+            if (findIndex(edgeFaces_[eIndex], removedFace) > -1)
+            {
+                meshOps::sizeDownList
+                (
+                    removedFace,
+                    edgeFaces_[eIndex]
+                );
+            }
+
+            if (findIndex(edgeFaces_[eIndex], retainedFace) > -1)
+            {
+                meshOps::sizeDownList
+                (
+                    retainedFace,
+                    edgeFaces_[eIndex]
+                );
+            }
+
+            // Size-up list with the new face index
+            meshOps::sizeUpList
+            (
+                newFaceIndex,
+                edgeFaces_[eIndex]
+            );
+
+            if (findIndex(checkEdges, eIndex) == -1)
+            {
+                checkEdges.append(eIndex);
+            }
+        }
+
+        // Remove the boundary faces
+        removeFace(removedFace);
+        removeFace(retainedFace);
+
+        // Update map
+        map.removeFace(removedFace);
+        map.removeFace(retainedFace);
+    }
+
+    forAll(checkEdges, edgeI)
+    {
+        bool allInterior = true;
+        label eIndex = checkEdges[edgeI];
+
+        const labelList& eFaces = edgeFaces_[eIndex];
+
+        forAll(eFaces, faceI)
+        {
+            if (whichPatch(eFaces[faceI]) > -1)
+            {
+                allInterior = false;
+                break;
+            }
+        }
+
+        if (allInterior)
+        {
+            // This edge needs to be converted to an interior one
+            label newEdgeIndex =
+            (
+                insertEdge
+                (
+                    -1,
+                    edge(edges_[eIndex]),
+                    labelList(edgeFaces_[eIndex])
+                )
+            );
+
+            // Update map
+            map.addEdge(newEdgeIndex, labelList(1, eIndex));
+
+            // Update faceEdges information for all connected faces
+            const labelList& neFaces = edgeFaces_[newEdgeIndex];
+
+            forAll(neFaces, faceI)
+            {
+                meshOps::replaceLabel
+                (
+                    eIndex,
+                    newEdgeIndex,
+                    faceEdges_[neFaces[faceI]]
+                );
+            }
+
+            // Remove the old boundary edge
+            removeEdge(eIndex);
+
+            // Update map
+            map.removeEdge(eIndex);
+
+            // Replace index
+            checkEdges[edgeI] = newEdgeIndex;
+        }
+    }
+
+    if (debug > 2)
+    {
+        Pout<< "Merge complete." << nl << endl;
+    }
+
+    // Return a succesful merge
+    map.type() = 1;
+
     return map;
 }
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
index 2c879cf70..2f602ddb1 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
@@ -24,14 +24,15 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "Stack.H"
+#include "dynamicTopoFvMesh.H"
+
 #include "triFace.H"
 #include "objectMap.H"
 #include "changeMap.H"
 #include "triPointRef.H"
 #include "linePointRef.H"
 #include "multiThreader.H"
-#include "dynamicTopoFvMesh.H"
+#include "coupledInfo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -41,72 +42,204 @@ namespace Foam
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Perform a Delaunay test on an internal face
+// - Returns 'true' if the test failed
 bool dynamicTopoFvMesh::testDelaunay
 (
     const label fIndex
 ) const
 {
-    bool failed = false;
-    label eIndex = -1, pIndex = -1, fLabel = -1;
-    FixedList<bool,2> foundTriFace(false);
-    FixedList<FixedList<label,3>,2> triFaces(FixedList<label,3>(-1));
+    bool failed = false, procCoupled = false;
+    label eIndex = -1, pointIndex = -1, fLabel = -1;
+    label sIndex = -1, pIndex = -1;
+    FixedList<triFace, 2> triFaces(triFace(-1, -1, -1));
+    FixedList<bool, 2> foundTriFace(false);
 
-    // Boundary faces are discarded.
-    if (whichPatch(fIndex) > -1)
+    // If this entity was deleted, skip it.
+    if (faces_[fIndex].empty())
     {
+        return failed;
+    }
+
+    // If face is not shared by prism cells, skip it.
+    label own = owner_[fIndex], nei = neighbour_[fIndex];
+
+    if (cells_[own].size() != 5)
+    {
+        return failed;
+    }
+
+    if (nei > -1)
+    {
+        if (cells_[nei].size() != 5)
         {
             return failed;
         }
     }
 
+    // Boundary faces are discarded.
+    if (whichPatch(fIndex) > -1)
     {
-        const labelList& fEdges = faceEdges_[fIndex];
+        procCoupled = processorCoupledEntity(fIndex);
 
-        forAll(fEdges, edgeI)
+        if (!procCoupled)
         {
-            // Break out if both triangular faces are found
-            if (foundTriFace[0] && foundTriFace[1])
+            return failed;
+        }
+    }
+
+    const labelList& fEdges = faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        // Break out if both triangular faces are found
+        if (foundTriFace[0] && foundTriFace[1])
+        {
+            break;
+        }
+
+        // Obtain edgeFaces for this edge
+        const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+        forAll(eFaces, faceI)
+        {
+            const face& thisFace = faces_[eFaces[faceI]];
+
+            if (thisFace.size() == 3)
             {
-                break;
-            }
-
-            // Obtain edgeFaces for this edge
-            const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
-
-            forAll(eFaces, faceI)
-            {
-                const face& thisFace = faces_[eFaces[faceI]];
-
-                if (thisFace.size() == 3)
+                if (foundTriFace[0])
                 {
-                    if (foundTriFace[0])
-                    {
-                        // Update the second face.
-                        triFaces[1][0] = thisFace[0];
-                        triFaces[1][1] = thisFace[1];
-                        triFaces[1][2] = thisFace[2];
+                    // Update the second face.
+                    triFaces[1][0] = thisFace[0];
+                    triFaces[1][1] = thisFace[1];
+                    triFaces[1][2] = thisFace[2];
 
+                    foundTriFace[1] = true;
+                }
+                else
+                {
+                    // Update the first face.
+                    triFaces[0][0] = thisFace[0];
+                    triFaces[0][1] = thisFace[1];
+                    triFaces[0][2] = thisFace[2];
+
+                    foundTriFace[0] = true;
+                    fLabel = eFaces[faceI];
+
+                    // Take this edge
+                    eIndex = fEdges[edgeI];
+
+                    if (procCoupled)
+                    {
+                        // Stop searching for processor boundary cases
                         foundTriFace[1] = true;
-
-                        // Take this edge
-                        eIndex = fEdges[edgeI];
-                    }
-                    else
-                    {
-                        // Update the first face.
-                        triFaces[0][0] = thisFace[0];
-                        triFaces[0][1] = thisFace[1];
-                        triFaces[0][2] = thisFace[2];
-
-                        foundTriFace[0] = true;
-
-                        fLabel = eFaces[faceI];
                     }
                 }
             }
         }
     }
 
+    const edge& checkEdge = edges_[eIndex];
+
+    // Configure the comparison edge
+    edge cEdge(-1, -1);
+
+    if (procCoupled)
+    {
+        // If this is a new entity, bail out for now.
+        // This will be handled at the next time-step.
+        if (fIndex >= nOldFaces_)
+        {
+            return failed;
+        }
+
+        const label faceEnum = coupleMap::FACE;
+        const label pointEnum = coupleMap::POINT;
+
+        // Check slaves
+        bool foundEdge = false;
+
+        forAll(procIndices_, pI)
+        {
+            // Fetch non-const reference to subMeshes
+            const coupledInfo& recvMesh = recvMeshes_[pI];
+
+            const coupleMap& cMap = recvMesh.map();
+            const dynamicTopoFvMesh& sMesh = recvMesh.subMesh();
+
+            if ((sIndex = cMap.findSlave(faceEnum, fIndex)) > -1)
+            {
+                // Find equivalent points on the slave
+                cEdge[0] = cMap.findSlave(pointEnum, checkEdge[0]);
+                cEdge[1] = cMap.findSlave(pointEnum, checkEdge[1]);
+
+                // Find a triangular face containing cEdge
+                const labelList& sfE = sMesh.faceEdges_[sIndex];
+
+                forAll(sfE, edgeI)
+                {
+                    // Obtain edgeFaces for this edge
+                    const labelList& seF = sMesh.edgeFaces_[sfE[edgeI]];
+
+                    forAll(seF, faceI)
+                    {
+                        const face& tF = sMesh.faces_[seF[faceI]];
+
+                        if (tF.size() == 3)
+                        {
+                            if
+                            (
+                                (findIndex(tF, cEdge[0]) > -1) &&
+                                (findIndex(tF, cEdge[1]) > -1)
+                            )
+                            {
+                                triFaces[1][0] = tF[0];
+                                triFaces[1][1] = tF[1];
+                                triFaces[1][2] = tF[2];
+
+                                foundEdge = true;
+
+                                break;
+                            }
+                        }
+                    }
+
+                    if (foundEdge)
+                    {
+                        break;
+                    }
+                }
+
+                // Store patch index for later
+                pIndex = pI;
+
+                break;
+            }
+        }
+
+        if (sIndex == -1 || !foundEdge)
+        {
+            // Write out for post-processing
+            writeVTK("coupledDelaunayFace_" + Foam::name(fIndex), fIndex, 2);
+
+            FatalErrorIn
+            (
+                "bool dynamicTopoFvMesh::testDelaunay"
+                "(const label fIndex) const"
+            )
+                << "Coupled maps were improperly specified." << nl
+                << " Slave index not found for: " << nl
+                << " Face: " << fIndex << nl
+                << " checkEdge: " << checkEdge << nl
+                << " cEdge: " << cEdge << nl
+                << abort(FatalError);
+        }
+    }
+    else
+    {
+        // Non-coupled case
+        cEdge = checkEdge;
+    }
+
     // Obtain point references for the first face
     point a = points_[triFaces[0][0]];
 
@@ -122,36 +255,40 @@ bool dynamicTopoFvMesh::testDelaunay
         ).circumCentre()
     );
 
-    point otherPoint = vector::zero;
-    scalar rSquared = (a - cCentre)&(a - cCentre);
+    scalar rSquared = (a - cCentre) & (a - cCentre);
 
     // Find the isolated point on the second face
+    point otherPoint = vector::zero;
+
+    // Check the first point
+    if (triFaces[1][0] != cEdge[0] && triFaces[1][0] != cEdge[1])
     {
-        const edge& e = edges_[eIndex];
-
-        // Check the first point
-        if (triFaces[1][0] != e.start() && triFaces[1][0] != e.end())
-        {
-            pIndex = triFaces[1][0];
-        }
-
-        // Check the second point
-        if (triFaces[1][1] != e.start() && triFaces[1][1] != e.end())
-        {
-            pIndex = triFaces[1][1];
-        }
-
-        // Check the third point
-        if (triFaces[1][2] != e.start() && triFaces[1][2] != e.end())
-        {
-            pIndex = triFaces[1][2];
-        }
-
-        // ...and determine whether it lies in this circle
-        otherPoint = points_[pIndex];
+        pointIndex = triFaces[1][0];
     }
 
-    if (((otherPoint - cCentre)&(otherPoint - cCentre)) < rSquared)
+    // Check the second point
+    if (triFaces[1][1] != cEdge[0] && triFaces[1][1] != cEdge[1])
+    {
+        pointIndex = triFaces[1][1];
+    }
+
+    // Check the third point
+    if (triFaces[1][2] != cEdge[0] && triFaces[1][2] != cEdge[1])
+    {
+        pointIndex = triFaces[1][2];
+    }
+
+    if (procCoupled)
+    {
+        otherPoint = recvMeshes_[pIndex].subMesh().points_[pointIndex];
+    }
+    else
+    {
+        otherPoint = points_[pointIndex];
+    }
+
+    // ...and determine whether it lies in this circle
+    if (((otherPoint - cCentre) & (otherPoint - cCentre)) < rSquared)
     {
         // Failed the test.
         failed = true;
@@ -176,17 +313,62 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
     bool found = false;
     label commonIndex = -1;
     FixedList<label,4> otherPointIndex(-1), nextToOtherPoint(-1);
-    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
-    FixedList<face,2>  c0BdyFace,  c0IntFace,  c1BdyFace,  c1IntFace;
+    FixedList<label,2> c0BdyIndex(-1), c0IntIndex(-1);
+    FixedList<label,2> c1BdyIndex(-1), c1IntIndex(-1);
+    FixedList<face,2> c0BdyFace(face(3)), c0IntFace(face(4));
+    FixedList<face,2> c1BdyFace(face(3)), c1IntFace(face(4));
     FixedList<label,2> commonEdgeIndex(-1);
-    FixedList<edge,2>  commonEdges;
+    FixedList<edge,2> commonEdges(edge(-1, -1));
     FixedList<label,4> otherEdgeIndex(-1);
     FixedList<label,4> commonFaceIndex(-1), cornerEdgeIndex(-1);
-    FixedList<face,4>  commonFaces(face(3)), commonIntFaces(face(4));
+    FixedList<face,4> commonFaces(face(3)), commonIntFaces(face(4));
     FixedList<label,4> commonIntFaceIndex(-1);
     FixedList<bool,2> foundTriFace0(false), foundTriFace1(false);
     FixedList<face,2> triFaces0(face(3)), triFaces1(face(3));
 
+    if (coupledModification_)
+    {
+        if (processorCoupledEntity(fIndex))
+        {
+            // When swapping across processors, we need to add the
+            // prism-cell from (as well as delete on) the patchSubMesh
+            const changeMap faceMap = insertCells(fIndex);
+
+            // Bail out if entity is handled elsewhere
+            if (faceMap.type() == -2)
+            {
+                return faceMap;
+            }
+
+            if (faceMap.type() != 1)
+            {
+                FatalErrorIn
+                (
+                    "const changeMap dynamicTopoFvMesh::swapQuadFace"
+                    "(const label fIndex)"
+                )
+                    << " Could not insert cells around face: " << fIndex
+                    << " :: " << faces_[fIndex] << nl
+                    << abort(FatalError);
+            }
+
+            // Figure out the new internal face index.
+            // This should not be a coupled face anymore.
+            label newIndex = faceMap.index();
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Recursively call this function for the new face
+            map = swapQuadFace(newIndex);
+
+            // Turn it back on.
+            setCoupledModification();
+
+            return map;
+        }
+    }
+
     // Get the two cells on either side...
     label c0 = owner_[fIndex];
     label c1 = neighbour_[fIndex];
@@ -513,24 +695,24 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
     // Perform a few debug calls before modifications
     if (debug > 1)
     {
-        Info << nl << nl << "Face: " << fIndex
-             << " needs to be flipped. " << endl;
-
-        Info << "Cell[0]: " << c0 << ": " << cells_[c0] << endl;
-        Info << "Cell[1]: " << c1 << ": " << cells_[c1] << endl;
+        Pout<< nl << nl << "Face: " << fIndex
+            << " needs to be flipped. " << endl;
 
         if (debug > 2)
         {
-            Info << "Common Faces: Set 1: "
-                 << commonFaceIndex[0] << ": " << commonFaces[0] << ", "
-                 << commonFaceIndex[1] << ": " << commonFaces[1] << endl;
+            Pout<< " Cell[0]: " << c0 << ": " << cells_[c0] << nl
+                << " Cell[1]: " << c1 << ": " << cells_[c1] << nl;
 
-            Info << "Common Faces: Set 2: "
-                 << commonFaceIndex[2] << ": " << commonFaces[2] << ", "
-                 << commonFaceIndex[3] << ": " << commonFaces[3] << endl;
+            Pout<< " Common Faces: Set 1: "
+                << commonFaceIndex[0] << ": " << commonFaces[0] << ", "
+                << commonFaceIndex[1] << ": " << commonFaces[1] << nl;
 
-            Info << "Old face: " << faces_[fIndex] << endl;
-            Info << "Old faceEdges: " << faceEdges_[fIndex] << endl;
+            Pout<< " Common Faces: Set 2: "
+                << commonFaceIndex[2] << ": " << commonFaces[2] << ", "
+                << commonFaceIndex[3] << ": " << commonFaces[3] << nl;
+
+            Pout<< " Old face: " << faces_[fIndex] << nl
+                << " Old faceEdges: " << faceEdges_[fIndex] << endl;
         }
 
         // Write out VTK files before change
@@ -541,12 +723,7 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
             cellHull[0] = c0;
             cellHull[1] = c1;
 
-            writeVTK
-            (
-                Foam::name(fIndex)
-              + "_Swap_0",
-                cellHull
-            );
+            writeVTK(Foam::name(fIndex) + "_Swap_0", cellHull);
         }
     }
 
@@ -710,17 +887,19 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
 
     if (debug > 1)
     {
-        Info << "New flipped face: " << newFace << endl;
+        Pout<< "New flipped face: " << newFace << nl;
 
         if (debug > 2)
         {
             forAll(newBdyFace, faceI)
             {
-                Info << "New boundary face[" << faceI << "]: "
-                     << commonFaceIndex[faceI]
-                     << ": " << newBdyFace[faceI] << endl;
+                Pout<< "New boundary face[" << faceI << "]: "
+                    << commonFaceIndex[faceI]
+                    << ": " << newBdyFace[faceI] << nl;
             }
         }
+
+        Pout<< endl;
     }
 
     // Check the orientation of the two quad faces, and modify as necessary
@@ -731,9 +910,9 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
     {
         // Boundary face
         // Face doesn't need to be flipped, just update the owner
-        f          = commonIntFaces[1];
-        newOwn     = c0;
-        newNei     = -1;
+        f = commonIntFaces[1];
+        newOwn = c0;
+        newNei = -1;
     }
     else
     if (owner_[commonIntFaceIndex[1]] == c1)
@@ -743,18 +922,18 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
         if (c0 > neighbour_[commonIntFaceIndex[1]])
         {
             // Flip is necessary
-            f          = commonIntFaces[1].reverseFace();
-            newOwn     = neighbour_[commonIntFaceIndex[1]];
-            newNei     = c0;
+            f = commonIntFaces[1].reverseFace();
+            newOwn = neighbour_[commonIntFaceIndex[1]];
+            newNei = c0;
 
             setFlip(commonIntFaceIndex[1]);
         }
         else
         {
             // Flip isn't necessary, just change the owner
-            f          = commonIntFaces[1];
-            newOwn     = c0;
-            newNei     = neighbour_[commonIntFaceIndex[1]];
+            f = commonIntFaces[1];
+            newOwn = c0;
+            newNei = neighbour_[commonIntFaceIndex[1]];
         }
     }
     else
@@ -765,18 +944,18 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
         if (c0 < owner_[commonIntFaceIndex[1]])
         {
             // Flip is necessary
-            f          = commonIntFaces[1].reverseFace();
-            newOwn     = c0;
-            newNei     = owner_[commonIntFaceIndex[1]];
+            f = commonIntFaces[1].reverseFace();
+            newOwn = c0;
+            newNei = owner_[commonIntFaceIndex[1]];
 
             setFlip(commonIntFaceIndex[1]);
         }
         else
         {
             // Flip isn't necessary, just change the neighbour
-            f          = commonIntFaces[1];
-            newOwn     = owner_[commonIntFaceIndex[1]];
-            newNei     = c0;
+            f = commonIntFaces[1];
+            newOwn = owner_[commonIntFaceIndex[1]];
+            newNei = c0;
         }
     }
 
@@ -791,9 +970,9 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
     {
         // Boundary face
         // Face doesn't need to be flipped, just update the owner
-        f          = commonIntFaces[2];
-        newOwn     = c1;
-        newNei     = -1;
+        f = commonIntFaces[2];
+        newOwn = c1;
+        newNei = -1;
     }
     else
     if (owner_[commonIntFaceIndex[2]] == c0)
@@ -803,18 +982,18 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
         if (c1 > neighbour_[commonIntFaceIndex[2]])
         {
             // Flip is necessary
-            f          = commonIntFaces[2].reverseFace();
-            newOwn     = neighbour_[commonIntFaceIndex[2]];
-            newNei     = c1;
+            f = commonIntFaces[2].reverseFace();
+            newOwn = neighbour_[commonIntFaceIndex[2]];
+            newNei = c1;
 
             setFlip(commonIntFaceIndex[2]);
         }
         else
         {
             // Flip isn't necessary, just change the owner
-            f          = commonIntFaces[2];
-            newOwn     = c1;
-            newNei     = neighbour_[commonIntFaceIndex[2]];
+            f = commonIntFaces[2];
+            newOwn = c1;
+            newNei = neighbour_[commonIntFaceIndex[2]];
         }
     }
     else
@@ -825,18 +1004,18 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
         if (c1 < owner_[commonIntFaceIndex[2]])
         {
             // Flip is necessary
-            f          = commonIntFaces[2].reverseFace();
-            newOwn     = c1;
-            newNei     = owner_[commonIntFaceIndex[2]];
+            f = commonIntFaces[2].reverseFace();
+            newOwn = c1;
+            newNei = owner_[commonIntFaceIndex[2]];
 
             setFlip(commonIntFaceIndex[2]);
         }
         else
         {
             // Flip isn't necessary, just change the neighbour
-            f          = commonIntFaces[2];
-            newOwn     = owner_[commonIntFaceIndex[2]];
-            newNei     = c1;
+            f = commonIntFaces[2];
+            newOwn = owner_[commonIntFaceIndex[2]];
+            newNei = c1;
         }
     }
 
@@ -904,74 +1083,6 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
 }
 
 
-// Method for the swapping of an edge in 3D
-//  - To be used mainly for testing purposes only.
-//  - Use swap3DEdges on the entire mesh for efficiency.
-void dynamicTopoFvMesh::swapEdge
-(
-    const label eIndex,
-    bool forceOp
-)
-{
-    // Dynamic programming variables
-    labelList m;
-    PtrList<scalarListList> Q;
-    PtrList<labelListList> K, triangulations;
-
-    // Allocate dynamic programming tables
-    initTables(m, Q, K, triangulations);
-
-    // Compute the minimum quality of cells around this edge
-    scalar minQuality = computeMinQuality(eIndex);
-
-    // Check if this edge is on a bounding curve
-    if (checkBoundingCurve(eIndex))
-    {
-        FatalErrorIn
-        (
-            "void dynamicTopoFvMesh::swapEdge"
-            "(const label eIndex, bool forceOp)"
-        )
-            << nl << " Cannot swap edges on bounding curves. "
-            << abort(FatalError);
-    }
-
-    // Fill the dynamic programming tables
-    if (fillTables(eIndex, minQuality, m, Q, K, triangulations))
-    {
-        // Check if edge-swapping is required.
-        scalar newQuality = Q[0][0][m[0]-1];
-
-        if (newQuality > minQuality)
-        {
-            // Remove this edge according to the swap sequence
-            removeEdgeFlips(eIndex, minQuality, K, triangulations);
-        }
-        else
-        if (forceOp)
-        {
-            if (newQuality < 0.0)
-            {
-                FatalErrorIn
-                (
-                    "void dynamicTopoFvMesh::swapEdge"
-                    "(const label eIndex, bool forceOp)"
-                )
-                    << " Forcing swap on edge: " << eIndex
-                    << ":: " << edges_[eIndex]
-                    << " will yield an invalid cell quality: "
-                    << newQuality << " Old Quality: " << minQuality
-                    << abort(FatalError);
-            }
-            else
-            {
-                removeEdgeFlips(eIndex, minQuality, K, triangulations);
-            }
-        }
-    }
-}
-
-
 // Allocate dynamic programming tables
 void dynamicTopoFvMesh::initTables
 (
@@ -996,11 +1107,7 @@ void dynamicTopoFvMesh::initTables
     }
 
     // Size all elements by default.
-    label numIndices = -1;
-
-    {
-        numIndices = 1;
-    }
+    label numIndices = coupledModification_ ? 2 : 1;
 
     m.setSize(numIndices, -1);
     Q.setSize(numIndices);
@@ -1036,16 +1143,39 @@ void dynamicTopoFvMesh::initTables
 bool dynamicTopoFvMesh::fillTables
 (
     const label eIndex,
-    const scalar minQuality,
+    scalar& minQuality,
     labelList& m,
+    labelList& hullVertices,
     PtrList<scalarListList>& Q,
     PtrList<labelListList>& K,
     PtrList<labelListList>& triangulations,
     const label checkIndex
 ) const
 {
+    // Obtain a reference to this edge
+    const labelList& edgeFaces = edgeFaces_[eIndex];
+
+    // If this entity was deleted, skip it.
+    if (edgeFaces.empty())
+    {
+        return false;
+    }
+
+    // Ensure that edge is surrounded by triangles
+    forAll(edgeFaces, faceI)
+    {
+        if (faces_[edgeFaces[faceI]].size() != 3)
+        {
+            return false;
+        }
+    }
+
     const edge& edgeToCheck = edges_[eIndex];
-    const labelList& hullVertices = edgePoints_[eIndex];
+
+    if (coupledModification_)
+    {
+        return coupledFillTables(eIndex, minQuality, m, Q, K, triangulations);
+    }
 
     // Fill in the size
     m[checkIndex] = hullVertices.size();
@@ -1076,18 +1206,54 @@ bool dynamicTopoFvMesh::fillTables
         }
     }
 
-    for (label i = (m[checkIndex]-3); i >= 0; i--)
+    // Fill dynamic programming tables
+    fillTables
+    (
+        edgeToCheck,
+        minQuality,
+        m[checkIndex],
+        hullVertices,
+        points_,
+        Q[checkIndex],
+        K[checkIndex],
+        triangulations[checkIndex]
+    );
+
+    // Print out tables for debugging
+    if (debug > 5)
     {
-        for (label j = i+2; j < m[checkIndex]; j++)
+        printTables(m, Q, K, checkIndex);
+    }
+
+    return true;
+}
+
+
+// Fill tables given addressing
+void dynamicTopoFvMesh::fillTables
+(
+    const edge& edgeToCheck,
+    const scalar minQuality,
+    const label m,
+    const labelList& hullVertices,
+    const UList<point>& points,
+    scalarListList& Q,
+    labelListList& K,
+    labelListList& triangulations
+) const
+{
+    for (label i = (m - 3); i >= 0; i--)
+    {
+        for (label j = i + 2; j < m; j++)
         {
-            for (label k = i+1; k < j; k++)
+            for (label k = i + 1; k < j; k++)
             {
                 scalar q = (*tetMetric_)
                 (
-                    points_[hullVertices[i]],
-                    points_[hullVertices[k]],
-                    points_[hullVertices[j]],
-                    points_[edgeToCheck[0]]
+                    points[hullVertices[i]],
+                    points[hullVertices[k]],
+                    points[hullVertices[j]],
+                    points[edgeToCheck[0]]
                 );
 
                 // For efficiency, check the bottom triangulation
@@ -1101,41 +1267,33 @@ bool dynamicTopoFvMesh::fillTables
                             q,
                             (*tetMetric_)
                             (
-                                points_[hullVertices[j]],
-                                points_[hullVertices[k]],
-                                points_[hullVertices[i]],
-                                points_[edgeToCheck[1]]
+                                points[hullVertices[j]],
+                                points[hullVertices[k]],
+                                points[hullVertices[i]],
+                                points[edgeToCheck[1]]
                             )
                         )
                     );
                 }
 
-                if (k < j-1)
+                if (k < j - 1)
                 {
-                    q = Foam::min(q,Q[checkIndex][k][j]);
+                    q = Foam::min(q, Q[k][j]);
                 }
 
-                if (k > i+1)
+                if (k > i + 1)
                 {
-                    q = Foam::min(q,Q[checkIndex][i][k]);
+                    q = Foam::min(q, Q[i][k]);
                 }
 
-                if ((k == i+1) || (q > Q[checkIndex][i][j]))
+                if ((k == i + 1) || (q > Q[i][j]))
                 {
-                    Q[checkIndex][i][j] = q;
-                    K[checkIndex][i][j] = k;
+                    Q[i][j] = q;
+                    K[i][j] = k;
                 }
             }
         }
     }
-
-    // Print out tables for debugging
-    if (debug > 3)
-    {
-        printTables(m, Q, K, checkIndex);
-    }
-
-    return true;
 }
 
 
@@ -1147,7 +1305,9 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
 (
     const label eIndex,
     const scalar minQuality,
-    const PtrList<labelListList>& K,
+    const labelList& vertexHull,
+    PtrList<scalarListList>& Q,
+    PtrList<labelListList>& K,
     PtrList<labelListList>& triangulations,
     const label checkIndex
 )
@@ -1156,17 +1316,117 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
 
     if (debug > 2)
     {
-        Info << " Removing edge : " << eIndex << " by flipping."
-             << " Edge: " << edges_[eIndex]
-             << " minQuality: " << minQuality << endl;
+        Pout<< nl << " Removing edge : " << eIndex << " by flipping."
+            << " Edge: " << edges_[eIndex]
+            << " minQuality: " << minQuality
+            << endl;
     }
 
-    // Make a copy of edgePoints, since it will be
-    // modified during swaps
-    labelList hullVertices(edgePoints_[eIndex]);
+    if (coupledModification_)
+    {
+        if (processorCoupledEntity(eIndex))
+        {
+            const changeMap edgeMap = insertCells(eIndex);
 
-    label m = hullVertices.size();
+            // Bail out if entity is handled elsewhere
+            if (edgeMap.type() == -2)
+            {
+                return edgeMap;
+            }
 
+            if (edgeMap.type() != 1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const scalar minQuality,\n"
+                    "    const labelList& vertexHull,\n"
+                    "    PtrList<scalarListList>& Q,\n"
+                    "    PtrList<labelListList>& K,\n"
+                    "    PtrList<labelListList>& triangulations,\n"
+                    "    const label checkIndex\n"
+                    ")\n"
+                )
+                    << " Could not insert cells around edge: " << eIndex
+                    << " :: " << edges_[eIndex] << nl
+                    << abort(FatalError);
+            }
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            // Re-fill tables for the reconfigured edge.
+            // This should not be a coupled edge anymore.
+            label newIndex = edgeMap.index();
+
+            if (processorCoupledEntity(newIndex))
+            {
+                // Write out edge connectivity
+                writeEdgeConnectivity(newIndex);
+
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const scalar minQuality,\n"
+                    "    const labelList& vertexHull,\n"
+                    "    PtrList<scalarListList>& Q,\n"
+                    "    PtrList<labelListList>& K,\n"
+                    "    PtrList<labelListList>& triangulations,\n"
+                    "    const label checkIndex\n"
+                    ")\n"
+                )
+                    << " Edge: " << newIndex
+                    << " :: " << edges_[newIndex] << nl
+                    << " is still processor-coupled. "
+                    << abort(FatalError);
+            }
+
+            const edge& newEdge = edges_[newIndex];
+
+            // Build vertexHull for this edge
+            labelList newVertexHull;
+            buildVertexHull(newIndex, newVertexHull);
+
+            fillTables
+            (
+                newEdge,
+                minQuality,
+                newVertexHull.size(),
+                newVertexHull,
+                points_,
+                Q[0],
+                K[0],
+                triangulations[0]
+            );
+
+            // Recursively call this function for the new edge
+            map =
+            (
+                removeEdgeFlips
+                (
+                    newIndex,
+                    minQuality,
+                    newVertexHull,
+                    Q,
+                    K,
+                    triangulations
+                )
+            );
+
+            // Turn it back on.
+            setCoupledModification();
+
+            return map;
+        }
+    }
+
+    label m = vertexHull.size();
     labelList hullFaces(m, -1);
     labelList hullCells(m, -1);
     labelList hullEdges(m, -1);
@@ -1183,7 +1443,7 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
         neighbour_,
         faceEdges_,
         edgeFaces_,
-        edgePoints_,
+        vertexHull,
         hullEdges,
         hullFaces,
         hullCells,
@@ -1208,7 +1468,7 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
         checkTriangulationVolumes
         (
             eIndex,
-            hullVertices,
+            vertexHull,
             triangulations[checkIndex]
         )
     )
@@ -1227,22 +1487,23 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
         identify32Swap
         (
             eIndex,
-            hullVertices,
+            vertexHull,
             triangulations[checkIndex]
         )
     );
 
     // Check that the triangulation is valid
+    label pIndex = -1;
 
     if (tF == -1)
     {
         const edge& edgeToCheck = edges_[eIndex];
 
-        Info << " All triangulations: " << nl
-             << ' ' << triangulations[checkIndex][0] << nl
-             << ' ' << triangulations[checkIndex][1] << nl
-             << ' ' << triangulations[checkIndex][2] << nl
-             << endl;
+        Pout<< " All triangulations: " << nl
+            << ' ' << triangulations[checkIndex][0] << nl
+            << ' ' << triangulations[checkIndex][1] << nl
+            << ' ' << triangulations[checkIndex][2] << nl
+            << endl;
 
         FatalErrorIn
         (
@@ -1251,7 +1512,9 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
             "(\n"
             "    const label eIndex,\n"
             "    const scalar minQuality,\n"
-            "    const PtrList<labelListList>& K,\n"
+            "    const labelList& vertexHull,\n"
+            "    PtrList<scalarListList>& Q,\n"
+            "    PtrList<labelListList>& K,\n"
             "    PtrList<labelListList>& triangulations,\n"
             "    const label checkIndex\n"
             ")\n"
@@ -1273,17 +1536,107 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
 
     if (debug > 2)
     {
-        Info << " Identified tF as: " << tF << endl;
-        Info << " Triangulation: "
-             << triangulations[checkIndex][0][tF] << " "
-             << triangulations[checkIndex][1][tF] << " "
-             << triangulations[checkIndex][2][tF] << " "
-             << endl;
-        Info << " All triangulations: " << nl
-             << ' ' << triangulations[checkIndex][0] << nl
-             << ' ' << triangulations[checkIndex][1] << nl
-             << ' ' << triangulations[checkIndex][2] << nl
-             << endl;
+        Pout<< " Identified tF as: " << tF << nl;
+
+        Pout<< " Triangulation: "
+            << triangulations[checkIndex][0][tF] << " "
+            << triangulations[checkIndex][1][tF] << " "
+            << triangulations[checkIndex][2][tF] << " "
+            << nl;
+
+        Pout<< " All triangulations: " << nl
+            << ' ' << triangulations[checkIndex][0] << nl
+            << ' ' << triangulations[checkIndex][1] << nl
+            << ' ' << triangulations[checkIndex][2] << nl
+            << endl;
+    }
+
+    if (coupledModification_)
+    {
+        if (locallyCoupledEntity(eIndex))
+        {
+            // Flip the slave edge as well.
+            label sIndex = -1;
+
+            // Determine the slave index.
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const label edgeEnum  = coupleMap::EDGE;
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
+
+                    if ((sIndex = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const scalar minQuality,\n"
+                    "    const labelList& vertexHull,\n"
+                    "    PtrList<scalarListList>& Q,\n"
+                    "    PtrList<labelListList>& K,\n"
+                    "    PtrList<labelListList>& triangulations,\n"
+                    "    const label checkIndex\n"
+                    ")\n"
+                )
+                    << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Edge: " << eIndex << nl
+                    << abort(FatalError);
+            }
+
+            if (debug > 2)
+            {
+                Pout<< nl << "Removing slave edge: " << sIndex
+                    << " for master edge: " << eIndex << endl;
+            }
+
+            // Build vertexHull for this edge
+            labelList slaveVertexHull;
+            buildVertexHull(sIndex, slaveVertexHull);
+
+            // Turn off switch temporarily.
+            unsetCoupledModification();
+
+            // Recursively call for the slave edge.
+            slaveMap =
+            (
+                removeEdgeFlips
+                (
+                    sIndex,
+                    minQuality,
+                    slaveVertexHull,
+                    Q,
+                    K,
+                    triangulations,
+                    1
+                )
+            );
+
+            // Turn it back on.
+            setCoupledModification();
+
+            // Bail out if the slave failed.
+            if (slaveMap.type() == -1)
+            {
+                // Reset all triangulations and bail out
+                triangulations[checkIndex][0] = -1;
+                triangulations[checkIndex][1] = -1;
+                triangulations[checkIndex][2] = -1;
+
+                return slaveMap;
+            }
+        }
     }
 
     // Perform a series of 2-3 swaps
@@ -1316,7 +1669,7 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
                             i,
                             numTriangulations,
                             triangulations[checkIndex],
-                            hullVertices,
+                            vertexHull,
                             hullFaces,
                             hullCells
                         )
@@ -1334,12 +1687,15 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
 
         if (numSwaps == 0)
         {
-            Info << "Triangulations: " << endl;
+            Pout<< "Triangulations: " << nl;
+
             forAll(triangulations[checkIndex], row)
             {
-                Info << triangulations[checkIndex][row] << endl;
+                Pout<< triangulations[checkIndex][row] << nl;
             }
 
+            Pout<<endl;
+
             // Should have performed at least one swap
             FatalErrorIn
             (
@@ -1348,7 +1704,9 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
                 "(\n"
                 "    const label eIndex,\n"
                 "    const scalar minQuality,\n"
-                "    const PtrList<labelListList>& K,\n"
+                "    const labelList& vertexHull,\n"
+                "    PtrList<scalarListList>& Q,\n"
+                "    PtrList<labelListList>& K,\n"
                 "    PtrList<labelListList>& triangulations,\n"
                 "    const label checkIndex\n"
                 ")\n"
@@ -1367,7 +1725,7 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
             tF,
             numTriangulations,
             triangulations[checkIndex],
-            hullVertices,
+            vertexHull,
             hullFaces,
             hullCells
         )
@@ -1378,9 +1736,123 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
     triangulations[checkIndex][1][tF] = -1;
     triangulations[checkIndex][2][tF] = -1;
 
+    // Update the coupled map
+    if (coupledModification_)
+    {
+        // Create a mapping entry for the new edge.
+        const coupleMap& cMap = patchCoupling_[pIndex].map();
+
+        if (locallyCoupledEntity(map.addedEdgeList()[0].index()))
+        {
+            cMap.mapSlave
+            (
+                coupleMap::EDGE,
+                map.addedEdgeList()[0].index(),
+                slaveMap.addedEdgeList()[0].index()
+            );
+
+            cMap.mapMaster
+            (
+                coupleMap::EDGE,
+                slaveMap.addedEdgeList()[0].index(),
+                map.addedEdgeList()[0].index()
+            );
+        }
+
+        // Add a mapping entry for two new faces as well.
+        face cF(3);
+
+        const List<objectMap>& amfList = map.addedFaceList();
+        const List<objectMap>& asfList = slaveMap.addedFaceList();
+
+        forAll(amfList, mfI)
+        {
+            // Configure a face for comparison.
+            const face& mF = faces_[amfList[mfI].index()];
+
+            forAll(mF, pointI)
+            {
+                cF[pointI] = cMap.entityMap(coupleMap::POINT)[mF[pointI]];
+            }
+
+            bool matched = false;
+
+            forAll(asfList, sfI)
+            {
+                const face& sF = faces_[asfList[sfI].index()];
+
+                if (triFace::compare(triFace(cF), triFace(sF)))
+                {
+                    cMap.mapSlave
+                    (
+                        coupleMap::FACE,
+                        amfList[mfI].index(),
+                        asfList[sfI].index()
+                    );
+
+                    cMap.mapMaster
+                    (
+                        coupleMap::FACE,
+                        asfList[sfI].index(),
+                        amfList[mfI].index()
+                    );
+
+                    matched = true;
+
+                    break;
+                }
+            }
+
+            if (!matched)
+            {
+                Pout<< "masterFaces: " << nl
+                    << amfList << endl;
+
+                Pout<< "slaveFaces: " << nl
+                    << asfList << endl;
+
+                forAll(amfList, mfI)
+                {
+                    Pout<< amfList[mfI].index() << ": "
+                        << faces_[amfList[mfI].index()]
+                        << nl;
+                }
+
+                forAll(asfList, sfI)
+                {
+                    Pout<< asfList[sfI].index() << ": "
+                        << faces_[asfList[sfI].index()]
+                        << nl;
+                }
+
+                Pout<< endl;
+
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const scalar minQuality,\n"
+                    "    const labelList& vertexHull,\n"
+                    "    PtrList<scalarListList>& Q,\n"
+                    "    PtrList<labelListList>& K,\n"
+                    "    PtrList<labelListList>& triangulations,\n"
+                    "    const label checkIndex\n"
+                    ")\n"
+                )
+                    << "Failed to build coupled face maps."
+                    << abort(FatalError);
+            }
+        }
+    }
+
     // Finally remove the edge
     removeEdge(eIndex);
 
+    // Update map
+    map.removeEdge(eIndex);
+
     // Increment the counter
     statistics_[1]++;
 
@@ -1427,7 +1899,8 @@ label dynamicTopoFvMesh::identify32Swap
 (
     const label eIndex,
     const labelList& hullVertices,
-    const labelListList& triangulations
+    const labelListList& triangulations,
+    bool output
 ) const
 {
     label m = hullVertices.size();
@@ -1456,7 +1929,6 @@ label dynamicTopoFvMesh::identify32Swap
                     points_[hullVertices[triangulations[2][i]]]
                 ),
                 segment,
-                1e-6,
                 intPt
             )
         );
@@ -1467,15 +1939,15 @@ label dynamicTopoFvMesh::identify32Swap
         }
     }
 
-    if (debug > 1)
+    if (debug > 1 || output)
     {
-        Info << nl << nl << "Hull Vertices: " << endl;
+        Pout<< nl << nl << "Hull Vertices: " << nl;
 
         forAll(hullVertices, vertexI)
         {
-            Info << hullVertices[vertexI] << ": "
-                 << points_[hullVertices[vertexI]]
-                 << endl;
+            Pout<< hullVertices[vertexI] << ": "
+                << points_[hullVertices[vertexI]]
+                << nl;
         }
 
         InfoIn
@@ -1485,23 +1957,21 @@ label dynamicTopoFvMesh::identify32Swap
             "(\n"
             "    const label eIndex,\n"
             "    const labelList& hullVertices,\n"
-            "    const labelListList& triangulations\n"
+            "    const labelListList& triangulations,\n"
+            "    bool output\n"
             ") const\n"
         )   << nl
             << "Could not determine 3-2 swap triangulation." << nl
             << "Edge: " << edgeToCheck << nl
             << "Edge Points: "
-            << segment.start() << ","
-            << segment.end() << nl
+            << segment.start() << "," << segment.end() << nl
             << endl;
     }
 
     // Could not find an intersecting triangulation.
-    //  - If this is a boundary edge, a curved surface-mesh.
+    //  - If this is a boundary edge, a curved surface-mesh
     //    was probably the reason why this failed.
     //  - If so, declare the nearest triangulation instead.
-    //  - Internal edges also occasionally encounter
-    //    precision issues. Use the same approach.
     vector eCentre = segment.centre();
 
     scalarField dist(m-2, 0.0);
@@ -1547,11 +2017,11 @@ label dynamicTopoFvMesh::identify32Swap
         }
     }
 
-    if (debug > 1)
+    if (debug > 1 || output)
     {
-        Info << " All distances :" << dist << nl
-             << " Triangulation index: " << mT
-             << endl;
+        Pout<< " All distances :" << dist << nl
+            << " Triangulation index: " << mT
+            << endl;
     }
 
     // Return the index
@@ -1618,115 +2088,165 @@ bool dynamicTopoFvMesh::boundaryTriangulation
 // Utility method to compute the minimum quality of a vertex hull
 scalar dynamicTopoFvMesh::computeMinQuality
 (
-    const label eIndex
+    const label eIndex,
+    labelList& hullVertices
 ) const
 {
     scalar minQuality = GREAT;
-    scalar cQuality = 0.0;
 
-    // Obtain a reference to this edge and corresponding edgePoints
+    // Obtain a reference to this edge
     const edge& edgeToCheck = edges_[eIndex];
-    const labelList& hullVertices = edgePoints_[eIndex];
+    const labelList& edgeFaces = edgeFaces_[eIndex];
 
-    // Obtain point references
-    const point& a = points_[edgeToCheck[0]];
-    const point& c = points_[edgeToCheck[1]];
-
-    if (whichEdgePatch(eIndex) < 0)
+    // If this entity was deleted, skip it.
+    if (edgeFaces.empty())
     {
-        // Internal edge.
-        forAll(hullVertices, indexI)
+        return minQuality;
+    }
+
+    // Ensure that edge is surrounded by triangles
+    forAll(edgeFaces, faceI)
+    {
+        if (faces_[edgeFaces[faceI]].size() != 3)
         {
-            label prevIndex = hullVertices.rcIndex(indexI);
-
-            // Pick vertices off the list
-            const point& b = points_[hullVertices[prevIndex]];
-            const point& d = points_[hullVertices[indexI]];
-
-            // Compute the quality
-            cQuality = tetMetric_(a, b, c, d);
-
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
+            return minQuality;
         }
     }
-    else
+
+    // Build vertexHull for this edge
+    buildVertexHull(eIndex, hullVertices);
+
+    if (coupledModification_)
     {
-        // Boundary edge.
-        for(label indexI = 1; indexI < hullVertices.size(); indexI++)
+        if (locallyCoupledEntity(eIndex))
         {
-            // Pick vertices off the list
-            const point& b = points_[hullVertices[indexI-1]];
-            const point& d = points_[hullVertices[indexI]];
+            // Compute the minimum quality of the slave edge as well.
+            label sIndex = -1;
 
-            // Compute the quality
-            cQuality = tetMetric_(a, b, c, d);
+            // Determine the slave index.
+            forAll(patchCoupling_, patchI)
+            {
+                if (patchCoupling_(patchI))
+                {
+                    const label edgeEnum  = coupleMap::EDGE;
+                    const coupleMap& cMap = patchCoupling_[patchI].map();
 
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
+                    if ((sIndex = cMap.findSlave(edgeEnum, eIndex)) > -1)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (sIndex == -1)
+            {
+                FatalErrorIn
+                (
+                    "scalar dynamicTopoFvMesh::computeMinQuality"
+                    "(const label eIndex, labelList& hullVertices) const"
+                )
+                    << nl << "Coupled maps were improperly specified." << nl
+                    << " Slave index not found for: " << nl
+                    << " Edge: " << eIndex << nl
+                    << abort(FatalError);
+            }
+
+            // Build vertexHull for this edge
+            labelList slaveVertexHull;
+            buildVertexHull(eIndex, slaveVertexHull);
+
+            // Temporarily turn off coupledModification
+            unsetCoupledModification();
+
+            scalar slaveQuality = computeMinQuality(sIndex, slaveVertexHull);
+
+            minQuality = Foam::min(slaveQuality, minQuality);
+
+            // Turn it back on.
+            setCoupledModification();
+        }
+        else
+        if (processorCoupledEntity(eIndex))
+        {
+            // Don't compute minQuality here, but do it in
+            // fillTables instead, while calculating hullPoints
+            return minQuality;
         }
     }
 
+    // Compute minQuality
+    minQuality =
+    (
+        Foam::min
+        (
+            computeMinQuality
+            (
+                edgeToCheck,
+                hullVertices,
+                points_,
+                (whichEdgePatch(eIndex) < 0)
+            ),
+            minQuality
+        )
+    );
+
     // Ensure that the mesh is valid
     if (minQuality < 0.0)
     {
-        // if (debug > 3)
+        // Write out faces and cells for post processing.
+        labelHashSet iFaces, iCells, bFaces;
+
+        const labelList& eFaces = edgeFaces_[eIndex];
+
+        forAll(eFaces, faceI)
         {
-            // Write out faces and cells for post processing.
-            labelHashSet iFaces, iCells, bFaces;
+            iFaces.insert(eFaces[faceI]);
 
-            const labelList& eFaces = edgeFaces_[eIndex];
-
-            forAll(eFaces, faceI)
+            if (!iCells.found(owner_[eFaces[faceI]]))
             {
-                iFaces.insert(eFaces[faceI]);
-
-                if (!iCells.found(owner_[eFaces[faceI]]))
-                {
-                    iCells.insert(owner_[eFaces[faceI]]);
-                }
-
-                if (!iCells.found(neighbour_[eFaces[faceI]]))
-                {
-                    iCells.insert(neighbour_[eFaces[faceI]]);
-                }
+                iCells.insert(owner_[eFaces[faceI]]);
             }
 
-            writeVTK(Foam::name(eIndex) + "_iCells", iCells.toc());
-            writeVTK(Foam::name(eIndex) + "_iFaces", iFaces.toc(), 2);
-
-            // Write out the boundary patches (for post-processing reference)
-            for
-            (
-                label faceI = nOldInternalFaces_;
-                faceI < faces_.size();
-                faceI++
-            )
+            if (!iCells.found(neighbour_[eFaces[faceI]]))
             {
-                if (faces_[faceI].empty())
-                {
-                    continue;
-                }
-
-                label pIndex = whichPatch(faceI);
-
-                if (pIndex != -1)
-                {
-                    bFaces.insert(faceI);
-                }
+                iCells.insert(neighbour_[eFaces[faceI]]);
             }
-
-            writeVTK(Foam::name(eIndex) + "_bFaces", bFaces.toc(), 2);
         }
 
+        writeVTK(Foam::name(eIndex) + "_iCells", iCells.toc());
+        writeVTK(Foam::name(eIndex) + "_iFaces", iFaces.toc(), 2);
+
+        // Write out the boundary patches (for post-processing reference)
+        for
+        (
+            label faceI = nOldInternalFaces_;
+            faceI < faces_.size();
+            faceI++
+        )
+        {
+            if (faces_[faceI].empty())
+            {
+                continue;
+            }
+
+            label pIndex = whichPatch(faceI);
+
+            if (pIndex != -1)
+            {
+                bFaces.insert(faceI);
+            }
+        }
+
+        writeVTK(Foam::name(eIndex) + "_bFaces", bFaces.toc(), 2);
+
         FatalErrorIn
         (
             "scalar dynamicTopoFvMesh::computeMinQuality"
-            "(const label eIndex) const"
+            "(const label eIndex, labelList& hullVertices) const"
         )
             << "Encountered negative cell-quality!" << nl
             << "Edge: " << eIndex << ": " << edgeToCheck << nl
-            << "EdgePoints: " << hullVertices << nl
+            << "vertexHull: " << hullVertices << nl
             << "Minimum Quality: " << minQuality
             << abort(FatalError);
     }
@@ -1735,9 +2255,47 @@ scalar dynamicTopoFvMesh::computeMinQuality
 }
 
 
+// Compute minQuality given addressing
+scalar dynamicTopoFvMesh::computeMinQuality
+(
+    const edge& edgeToCheck,
+    const labelList& hullVertices,
+    const UList<point>& points,
+    bool closedRing
+) const
+{
+    scalar cQuality = 0.0;
+    scalar minQuality = GREAT;
+
+    // Obtain point references
+    const point& a = points[edgeToCheck[0]];
+    const point& c = points[edgeToCheck[1]];
+
+    label start = (closedRing ? 0 : 1);
+
+    for (label indexJ = start; indexJ < hullVertices.size(); indexJ++)
+    {
+        label indexI = hullVertices.rcIndex(indexJ);
+
+        // Pick vertices off the list
+        const point& b = points[hullVertices[indexI]];
+        const point& d = points[hullVertices[indexJ]];
+
+        // Compute the quality
+        cQuality = tetMetric_(a, b, c, d);
+
+        // Check if the quality is worse
+        minQuality = Foam::min(cQuality, minQuality);
+    }
+
+    return minQuality;
+}
+
+
 // Method used to perform a 2-3 swap in 3D
-// - Returns a changeMap with the index of
-//   the triangulated face in opposingFace.
+// - Returns a changeMap with a type specifying:
+//     1: Swap was successful
+// - The index of the triangulated face in map.index()
 const changeMap dynamicTopoFvMesh::swap23
 (
     const label isolatedVertex,
@@ -1751,12 +2309,12 @@ const changeMap dynamicTopoFvMesh::swap23
 )
 {
     // A 2-3 swap performs the following operations:
-    //      [1] Remove face: [ edge[0] edge[1] isolatedVertex ]
+    //      [1] Remove face: [ edgeToCheck[0] edgeToCheck[1] isolatedVertex ]
     //      [2] Remove two cells on either side of removed face
     //      [3] Add one edge
     //      [4] Add three new faces
     //      [5] Add three new cells
-    //      Update faceEdges, edgeFaces and edgePoints information
+    //      Update faceEdges and edgeFaces information
 
     changeMap map;
 
@@ -1774,32 +2332,42 @@ const changeMap dynamicTopoFvMesh::swap23
     if (debug > 1)
     {
         // Print out arguments
-        Info << endl;
-        Info << "== Swapping 2-3 ==" << endl;
-        Info << "Edge: " << eIndex << ": " << edgeToCheck << endl;
+        Pout<< nl
+            << "== Swapping 2-3 ==" << nl
+            << "Edge: " << eIndex << ": " << edgeToCheck << endl;
 
         if (debug > 2)
         {
+            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " coupledModification: " << coupledModification_ << nl;
+
             label bPatch = whichEdgePatch(eIndex);
 
+            const polyBoundaryMesh& boundary = boundaryMesh();
+
             if (bPatch == -1)
             {
-                Info << "Patch: Internal" << endl;
+                Pout<< " Patch: Internal" << nl;
+            }
+            else
+            if (bPatch < boundary.size())
+            {
+                Pout<< " Patch: " << boundary[bPatch].name() << nl;
             }
             else
             {
-                Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+                Pout<< " New patch: " << bPatch << endl;
             }
 
-            Info << "Ring: " << hullVertices << endl;
-            Info << "Faces: " << hullFaces << endl;
-            Info << "Cells: " << hullCells << endl;
-            Info << "Triangulation: "
-                 << triangulations[0][triangulationIndex] << " "
-                 << triangulations[1][triangulationIndex] << " "
-                 << triangulations[2][triangulationIndex] << " "
-                 << endl;
-            Info << "Isolated vertex: " << isolatedVertex << endl;
+            Pout<< " Ring: " << hullVertices << nl
+                << " Faces: " << hullFaces << nl
+                << " Cells: " << hullCells << nl
+                << " Triangulation: "
+                << triangulations[0][triangulationIndex] << " "
+                << triangulations[1][triangulationIndex] << " "
+                << triangulations[2][triangulationIndex] << " "
+                << nl
+                << " Isolated vertex: " << isolatedVertex << endl;
         }
 
         if (debug > 3)
@@ -1812,7 +2380,8 @@ const changeMap dynamicTopoFvMesh::swap23
               + "_beforeSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                cellsForRemoval
+                cellsForRemoval,
+                3, false, true
             );
         }
     }
@@ -1821,9 +2390,17 @@ const changeMap dynamicTopoFvMesh::swap23
     if (cellsForRemoval[1] == -1)
     {
         // Write out for post-processing
+        Pout<< " isolatedVertex: " << isolatedVertex << nl
+            << " triangulations: " << triangulations << nl
+            << " numTriangulations: " << numTriangulations << nl
+            << " triangulationIndex: " << triangulationIndex << endl;
+
         writeVTK("Edge23_" + Foam::name(eIndex), eIndex, 1);
         writeVTK("Cells23_" + Foam::name(eIndex), hullCells, 3);
 
+        // Write out identify32Swap output for diagnostics
+        identify32Swap(eIndex, hullVertices, triangulations, true);
+
         FatalErrorIn
         (
             "\n"
@@ -1868,6 +2445,9 @@ const changeMap dynamicTopoFvMesh::swap23
 
         // Insert the cell
         newCellIndex[cellI] = insertCell(newTetCell[cellI], avgScale);
+
+        // Add this cell to the map.
+        map.addCell(newCellIndex[cellI]);
     }
 
     // Obtain point-ordering for the other vertices
@@ -1912,8 +2492,11 @@ const changeMap dynamicTopoFvMesh::swap23
         )
     );
 
-    // Add an entry to the map
-    map.opposingFace() = newFaceIndex[0];
+    // Add this face to the map.
+    map.addFace(newFaceIndex[0]);
+
+    // Note the triangulation face in index()
+    map.index() = newFaceIndex[0];
 
     // Second face: Triangle involving edgeToCheck[0]
     tmpTriFace[0] = otherVertices[0];
@@ -1931,6 +2514,9 @@ const changeMap dynamicTopoFvMesh::swap23
         )
     );
 
+    // Add this face to the map.
+    map.addFace(newFaceIndex[1]);
+
     // Third face: Triangle involving edgeToCheck[1]
     tmpTriFace[0] = otherVertices[1];
     tmpTriFace[1] = edgeToCheck[1];
@@ -1947,6 +2533,9 @@ const changeMap dynamicTopoFvMesh::swap23
         )
     );
 
+    // Add this face to the map.
+    map.addFace(newFaceIndex[2]);
+
     // Append three dummy faceEdges entries.
     for (label i = 0; i < 3; i++)
     {
@@ -1959,12 +2548,6 @@ const changeMap dynamicTopoFvMesh::swap23
     newEdgeFaces[1] = newFaceIndex[1];
     newEdgeFaces[2] = newFaceIndex[2];
 
-    // Add an entry for edgePoints as well
-    labelList newEdgePoints(3);
-    newEdgePoints[0] = vertexForRemoval;
-    newEdgePoints[1] = edgeToCheck[0];
-    newEdgePoints[2] = edgeToCheck[1];
-
     // Add a new internal edge to the mesh
     label newEdgeIndex =
     (
@@ -1976,11 +2559,13 @@ const changeMap dynamicTopoFvMesh::swap23
                 otherVertices[0],
                 otherVertices[1]
             ),
-            newEdgeFaces,
-            newEdgePoints
+            newEdgeFaces
         )
     );
 
+    // Add this edge to the map.
+    map.addEdge(newEdgeIndex);
+
     // Define the six edges to check while building faceEdges:
     FixedList<edge,6> check;
 
@@ -2074,7 +2659,7 @@ const changeMap dynamicTopoFvMesh::swap23
                 // Add this face to the cell
                 newTetCell[1][nF1++] = faceIndex;
 
-                // Update faceEdges, edgeFaces, and edgePoints.
+                // Update faceEdges and edgeFaces
                 forAll(faceEdges_[faceIndex], edgeI)
                 {
                     if (edges_[faceEdges_[faceIndex][edgeI]] == check[0])
@@ -2086,14 +2671,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[0],
                             edgeFaces_[faceEdges_[faceIndex][edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[1],
-                            edgeToCheck[0],
-                            edgeToCheck[1],
-                            edgePoints_[faceEdges_[faceIndex][edgeI]]
-                        );
                     }
 
                     if (edges_[faceEdges_[faceIndex][edgeI]] == check[1])
@@ -2105,14 +2682,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[0],
                             edgeFaces_[faceEdges_[faceIndex][edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[0],
-                            edgeToCheck[0],
-                            edgeToCheck[1],
-                            edgePoints_[faceEdges_[faceIndex][edgeI]]
-                        );
                     }
 
                     if (edges_[faceEdges_[faceIndex][edgeI]] == check[2])
@@ -2124,14 +2693,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[1],
                             edgeFaces_[faceEdges_[faceIndex][edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[1],
-                            vertexForRemoval,
-                            edgeToCheck[1],
-                            edgePoints_[faceEdges_[faceIndex][edgeI]]
-                        );
                     }
 
                     if (edges_[faceEdges_[faceIndex][edgeI]] == check[4])
@@ -2143,14 +2704,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[1],
                             edgeFaces_[faceEdges_[faceIndex][edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[0],
-                            vertexForRemoval,
-                            edgeToCheck[1],
-                            edgePoints_[faceEdges_[faceIndex][edgeI]]
-                        );
                     }
                 }
             }
@@ -2185,7 +2738,7 @@ const changeMap dynamicTopoFvMesh::swap23
                 // Add this face to the cell
                 newTetCell[0][nF0++] = faceIndex;
 
-                // Update faceEdges, edgeFaces, and edgePoints.
+                // Update faceEdges and edgeFaces
                 const labelList& fEdges = faceEdges_[faceIndex];
 
                 forAll(fEdges, edgeI)
@@ -2199,14 +2752,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[2],
                             edgeFaces_[fEdges[edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[1],
-                            vertexForRemoval,
-                            edgeToCheck[0],
-                            edgePoints_[fEdges[edgeI]]
-                        );
                     }
 
                     if (edges_[fEdges[edgeI]] == check[5])
@@ -2218,14 +2763,6 @@ const changeMap dynamicTopoFvMesh::swap23
                             newFaceIndex[2],
                             edgeFaces_[fEdges[edgeI]]
                         );
-
-                        meshOps::insertLabel
-                        (
-                            otherVertices[0],
-                            vertexForRemoval,
-                            edgeToCheck[0],
-                            edgePoints_[fEdges[edgeI]]
-                        );
                     }
                 }
             }
@@ -2273,9 +2810,7 @@ const changeMap dynamicTopoFvMesh::swap23
         faceEdges_[newFaceIndex[faceI]] = newFaceEdges[faceI];
     }
 
-    // Update edgeFaces and edgePoints for edges of the removed face
-    label otherPoint = -1, nextPoint = -1;
-
+    // Update edgeFaces for edges of the removed face
     forAll(faceEdges_[faceForRemoval], edgeI)
     {
         label edgeIndex = faceEdges_[faceForRemoval][edgeI];
@@ -2285,37 +2820,20 @@ const changeMap dynamicTopoFvMesh::swap23
             faceForRemoval,
             edgeFaces_[edgeIndex]
         );
-
-        // Find the isolated point and remove it
-        meshOps::findIsolatedPoint
-        (
-            faces_[faceForRemoval],
-            edges_[edgeIndex],
-            otherPoint,
-            nextPoint
-        );
-
-        meshOps::sizeDownList
-        (
-            otherPoint,
-            edgePoints_[edgeIndex]
-        );
     }
 
     // Remove the face
     removeFace(faceForRemoval);
 
+    // Update map
+    map.removeFace(faceForRemoval);
+
     forAll(cellsForRemoval, cellI)
     {
         removeCell(cellsForRemoval[cellI]);
-    }
 
-    // Fill-in candidate mapping information
-    labelList mC(2, -1);
-
-    forAll(mC, indexI)
-    {
-        mC[indexI] = cellsForRemoval[indexI];
+        // Update map
+        map.removeCell(cellsForRemoval[cellI]);
     }
 
     // Update the cell list with newly configured cells.
@@ -2326,12 +2844,12 @@ const changeMap dynamicTopoFvMesh::swap23
         if (cellI == 2)
         {
             // Skip mapping for the intermediate cell.
-            setCellMapping(newCellIndex[cellI], mC, false);
+            setCellMapping(newCellIndex[cellI], hullCells, false);
         }
         else
         {
             // Set the mapping for this cell
-            setCellMapping(newCellIndex[cellI], mC);
+            setCellMapping(newCellIndex[cellI], hullCells);
         }
     }
 
@@ -2344,34 +2862,36 @@ const changeMap dynamicTopoFvMesh::swap23
 
     if (debug > 2)
     {
-        Info << "Added edge: " << endl;
+        Pout<< "Added edge: " << nl;
 
-        Info << newEdgeIndex << ":: "
-             << edges_[newEdgeIndex]
-             << " edgeFaces: "
-             << edgeFaces_[newEdgeIndex]
-             << endl;
+        Pout<< newEdgeIndex << ":: "
+            << edges_[newEdgeIndex]
+            << " edgeFaces: "
+            << edgeFaces_[newEdgeIndex]
+            << nl;
 
-        Info << "Added faces: " << endl;
+        Pout<< "Added faces: " << nl;
 
         forAll(newFaceIndex, faceI)
         {
-            Info << newFaceIndex[faceI] << ":: "
-                 << faces_[newFaceIndex[faceI]]
-                 << " faceEdges: "
-                 << faceEdges_[newFaceIndex[faceI]]
-                 << endl;
+            Pout<< newFaceIndex[faceI] << ":: "
+                << faces_[newFaceIndex[faceI]]
+                << " faceEdges: "
+                << faceEdges_[newFaceIndex[faceI]]
+                << nl;
         }
 
-        Info << "Added cells: " << endl;
+        Pout<< "Added cells: " << nl;
 
         forAll(newCellIndex, cellI)
         {
-            Info << newCellIndex[cellI] << ":: "
-                 << cells_[newCellIndex[cellI]]
-                 << endl;
+            Pout<< newCellIndex[cellI] << ":: "
+                << cells_[newCellIndex[cellI]]
+                << nl;
         }
 
+        Pout<< endl;
+
         if (debug > 3)
         {
             writeVTK
@@ -2382,7 +2902,8 @@ const changeMap dynamicTopoFvMesh::swap23
               + "_afterSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                newCellIndex
+                newCellIndex,
+                3, false, true
             );
         }
     }
@@ -2398,8 +2919,7 @@ const changeMap dynamicTopoFvMesh::swap23
 // Method used to perform a 2-2 / 3-2 swap in 3D
 // - Returns a changeMap with a type specifying:
 //     1: Swap was successful
-// - The index of the triangulated face in opposingFace.
-// - For 2-2 swaps, the newly added edge index.
+// - The index of the triangulated face in map.index()
 const changeMap dynamicTopoFvMesh::swap32
 (
     const label eIndex,
@@ -2420,7 +2940,7 @@ const changeMap dynamicTopoFvMesh::swap32
     //      [5] If edgeToCheck is on a boundary,
     //          add two boundary faces and a boundary edge (2-2 swap)
     //      eIndex is removed later by removeEdgeFlips
-    //      Update faceEdges, edgeFaces and edgePoints information
+    //      Update faceEdges and edgeFaces information
 
     changeMap map;
 
@@ -2432,7 +2952,7 @@ const changeMap dynamicTopoFvMesh::swap32
 
     // Determine the three faces to be removed
     FixedList<label,3> facesForRemoval;
-    labelHashSet cellsForRemoval(3);
+    DynamicList<label> cellRemovalList(3);
 
     forAll(facesForRemoval, faceI)
     {
@@ -2445,56 +2965,67 @@ const changeMap dynamicTopoFvMesh::swap32
         label nei = neighbour_[facesForRemoval[faceI]];
 
         // Check and add cells as well
-        if (!cellsForRemoval.found(own))
+        if (findIndex(cellRemovalList, own) == -1)
         {
-            cellsForRemoval.insert(own);
+            cellRemovalList.append(own);
         }
 
-        if (!cellsForRemoval.found(nei) && nei != -1)
+        if (nei != -1)
         {
-            cellsForRemoval.insert(nei);
+            if (findIndex(cellRemovalList, nei) == -1)
+            {
+                cellRemovalList.append(nei);
+            }
         }
     }
 
-    labelList cellRemovalList = cellsForRemoval.toc();
-
     if (debug > 1)
     {
         // Print out arguments
-        Info << endl;
+        Pout<< nl;
 
         if (edgePatch < 0)
         {
-            Info << "== Swapping 3-2 ==" << endl;
+            Pout<< "== Swapping 3-2 ==" << nl;
         }
         else
         {
-            Info << "== Swapping 2-2 ==" << endl;
+            Pout<< "== Swapping 2-2 ==" << nl;
         }
 
-        Info << "Edge: " << eIndex << ": " << edgeToCheck << endl;
+        Pout<< " Edge: " << eIndex << ": " << edgeToCheck << endl;
 
         if (debug > 2)
         {
+            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " coupledModification: " << coupledModification_ << nl;
+
             label bPatch = whichEdgePatch(eIndex);
 
+            const polyBoundaryMesh& boundary = boundaryMesh();
+
             if (bPatch == -1)
             {
-                Info << "Patch: Internal" << endl;
+                Pout<< " Patch: Internal" << nl;
+            }
+            else
+            if (bPatch < boundary.size())
+            {
+                Pout<< " Patch: " << boundary[bPatch].name() << nl;
             }
             else
             {
-                Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+                Pout<< " New patch: " << bPatch << endl;
             }
 
-            Info << "Ring: " << hullVertices << endl;
-            Info << "Faces: " << hullFaces << endl;
-            Info << "Cells: " << hullCells << endl;
-            Info << "Triangulation: "
-                 << triangulations[0][triangulationIndex] << " "
-                 << triangulations[1][triangulationIndex] << " "
-                 << triangulations[2][triangulationIndex] << " "
-                 << endl;
+            Pout<< " Ring: " << hullVertices << nl
+                << " Faces: " << hullFaces << nl
+                << " Cells: " << hullCells << nl
+                << " Triangulation: "
+                << triangulations[0][triangulationIndex] << " "
+                << triangulations[1][triangulationIndex] << " "
+                << triangulations[2][triangulationIndex] << " "
+                << endl;
         }
 
         if (debug > 3)
@@ -2507,7 +3038,8 @@ const changeMap dynamicTopoFvMesh::swap32
               + "_beforeSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                cellRemovalList
+                cellRemovalList,
+                3, false, true
             );
         }
     }
@@ -2532,6 +3064,9 @@ const changeMap dynamicTopoFvMesh::swap32
 
         // Insert the cell
         newCellIndex[cellI] = insertCell(newTetCell[cellI], avgScale);
+
+        // Add this cell to the map.
+        map.addCell(newCellIndex[cellI]);
     }
 
     // Insert a new internal face
@@ -2552,8 +3087,11 @@ const changeMap dynamicTopoFvMesh::swap32
         )
     );
 
-    // Add an entry to the map
-    map.opposingFace() = newFaceIndex;
+    // Add this face to the map.
+    map.addFace(newFaceIndex);
+
+    // Note the triangulation face in index()
+    map.index() = newFaceIndex;
 
     // Add faceEdges for the new face as well.
     faceEdges_.append(labelList(3));
@@ -2713,12 +3251,6 @@ const changeMap dynamicTopoFvMesh::swap32
             nextPoint
         );
 
-        // Add an edgePoints entry
-        labelList newBdyEdgePoints(3, -1);
-        newBdyEdgePoints[0] = edgeToCheck[0];
-        newBdyEdgePoints[1] = otherPoint;
-        newBdyEdgePoints[2] = edgeToCheck[1];
-
         // Insert the edge
         newEdgeIndex =
         (
@@ -2726,8 +3258,7 @@ const changeMap dynamicTopoFvMesh::swap32
             (
                 edgePatch,
                 newEdge,
-                newBdyEdgeFaces,
-                newBdyEdgePoints
+                newBdyEdgeFaces
             )
         );
 
@@ -2739,7 +3270,7 @@ const changeMap dynamicTopoFvMesh::swap32
         bdyFaceEdges[0][nBE[0]++] = newEdgeIndex;
         bdyFaceEdges[1][nBE[1]++] = newEdgeIndex;
 
-        // Update edgeFaces and edgePoints with the two new faces
+        // Update edgeFaces with the two new faces
         forAll(bdyEdges[0], edgeI)
         {
             meshOps::sizeUpList
@@ -2753,52 +3284,6 @@ const changeMap dynamicTopoFvMesh::swap32
                 newBdyFaceIndex[1],
                 edgeFaces_[bdyEdges[1][edgeI]]
             );
-
-            // Replace the edgePoints label, and preserve position on the list
-            meshOps::findIsolatedPoint
-            (
-                newBdyTriFace[0],
-                edges_[bdyEdges[0][edgeI]],
-                otherPoint,
-                nextPoint
-            );
-
-            meshOps::replaceLabel
-            (
-                edgeToCheck[1],
-                otherPoint,
-                edgePoints_[bdyEdges[0][edgeI]]
-            );
-
-            // Size up edgePoints again, so that it is sized down later
-            meshOps::sizeUpList
-            (
-                edgeToCheck[1],
-                edgePoints_[bdyEdges[0][edgeI]]
-            );
-
-            // Replace the edgePoints label, and preserve position on the list
-            meshOps::findIsolatedPoint
-            (
-                newBdyTriFace[1],
-                edges_[bdyEdges[1][edgeI]],
-                otherPoint,
-                nextPoint
-            );
-
-            meshOps::replaceLabel
-            (
-                edgeToCheck[0],
-                otherPoint,
-                edgePoints_[bdyEdges[1][edgeI]]
-            );
-
-            // Size up edgePoints again, so that it is sized down later
-            meshOps::sizeUpList
-            (
-                edgeToCheck[0],
-                edgePoints_[bdyEdges[1][edgeI]]
-            );
         }
 
         // Add faceEdges for the two new boundary faces
@@ -2867,7 +3352,7 @@ const changeMap dynamicTopoFvMesh::swap32
                 // Add this face to the cell
                 newTetCell[1][nF1++] = faceIndex;
 
-                // Update faceEdges, edgeFaces and edgePoints
+                // Update faceEdges and edgeFaces
                 forAll(faceEdges_[faceIndex], edgeI)
                 {
                     if
@@ -2888,23 +3373,6 @@ const changeMap dynamicTopoFvMesh::swap32
                             edgeFaces_[faceEdges_[faceIndex][edgeI]]
                         );
 
-                        // Find the isolated point and insert it
-                        meshOps::findIsolatedPoint
-                        (
-                            newTriFace,
-                            edges_[faceEdges_[faceIndex][edgeI]],
-                            otherPoint,
-                            nextPoint
-                        );
-
-                        meshOps::insertLabel
-                        (
-                            otherPoint,
-                            edgeToCheck[0],
-                            edgeToCheck[1],
-                            edgePoints_[faceEdges_[faceIndex][edgeI]]
-                        );
-
                         break;
                     }
                 }
@@ -2946,7 +3414,7 @@ const changeMap dynamicTopoFvMesh::swap32
     // Remove the faces and update associated edges
     forAll(facesForRemoval, faceI)
     {
-        // Update edgeFaces and edgePoints
+        // Update edgeFaces
         forAll(faceEdges_[facesForRemoval[faceI]], edgeI)
         {
             label edgeIndex = faceEdges_[facesForRemoval[faceI]][edgeI];
@@ -2958,31 +3426,22 @@ const changeMap dynamicTopoFvMesh::swap32
                     facesForRemoval[faceI],
                     edgeFaces_[edgeIndex]
                 );
-
-                // Find the isolated point and remove it
-                meshOps::findIsolatedPoint
-                (
-                    faces_[facesForRemoval[faceI]],
-                    edges_[edgeIndex],
-                    otherPoint,
-                    nextPoint
-                );
-
-                meshOps::sizeDownList
-                (
-                    otherPoint,
-                    edgePoints_[edgeIndex]
-                );
             }
         }
 
         // Now remove the face...
         removeFace(facesForRemoval[faceI]);
+
+        // Update map
+        map.removeFace(facesForRemoval[faceI]);
     }
 
     forAll(cellRemovalList, cellI)
     {
         removeCell(cellRemovalList[cellI]);
+
+        // Update map
+        map.removeCell(cellRemovalList[cellI]);
     }
 
     // Update the cell list with newly configured cells.
@@ -2990,16 +3449,8 @@ const changeMap dynamicTopoFvMesh::swap32
     {
         cells_[newCellIndex[cellI]] = newTetCell[cellI];
 
-        // Fill-in candidate mapping information
-        labelList mC(cellRemovalList.size(), -1);
-
-        forAll(mC, indexI)
-        {
-            mC[indexI] = cellRemovalList[indexI];
-        }
-
         // Set the mapping for this cell
-        setCellMapping(newCellIndex[cellI], mC);
+        setCellMapping(newCellIndex[cellI], hullCells);
     }
 
     // Set fill-in mapping for two new boundary faces
@@ -3020,45 +3471,46 @@ const changeMap dynamicTopoFvMesh::swap32
     {
         if (edgePatch > -1)
         {
-            Info << "Added edge: " << endl;
-
-            Info << newEdgeIndex << ":: "
-                 << edges_[newEdgeIndex]
-                 << " edgeFaces: "
-                 << edgeFaces_[newEdgeIndex]
-                 << endl;
+            Pout<< "Added edge: "
+                << newEdgeIndex << ":: "
+                << edges_[newEdgeIndex]
+                << " edgeFaces: "
+                << edgeFaces_[newEdgeIndex]
+                << endl;
         }
 
-        Info << "Added face(s): " << endl;
+        Pout<< "Added face(s): " << nl;
 
-        Info << newFaceIndex << ":: "
-             << faces_[newFaceIndex];
+        Pout<< newFaceIndex << ":: "
+            << faces_[newFaceIndex];
 
-        Info << " faceEdges: "
-             << faceEdges_[newFaceIndex]
-             << endl;
+        Pout<< " faceEdges: "
+            << faceEdges_[newFaceIndex]
+            << endl;
 
         if (edgePatch > -1)
         {
             forAll(newBdyFaceIndex, faceI)
             {
-                Info << newBdyFaceIndex[faceI] << ":: "
-                     << faces_[newBdyFaceIndex[faceI]]
-                     << " faceEdges: "
-                     << faceEdges_[newBdyFaceIndex[faceI]]
-                     << endl;
+                Pout<< newBdyFaceIndex[faceI] << ":: "
+                    << faces_[newBdyFaceIndex[faceI]]
+                    << " faceEdges: "
+                    << faceEdges_[newBdyFaceIndex[faceI]]
+                    << nl;
             }
         }
 
-        Info << "Added cells: " << endl;
+        Pout<< "Added cells: " << nl;
 
         forAll(newCellIndex, cellI)
         {
-            Info << newCellIndex[cellI] << ":: "
-                 << cells_[newCellIndex[cellI]]
-                 << endl;
+            Pout<< newCellIndex[cellI] << ":: "
+                << cells_[newCellIndex[cellI]]
+                << nl;
         }
 
+        Pout<< endl;
+
         if (debug > 3)
         {
             writeVTK
@@ -3069,7 +3521,8 @@ const changeMap dynamicTopoFvMesh::swap32
               + "_afterSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                newCellIndex
+                newCellIndex,
+                3, false, true
             );
         }
     }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
new file mode 100644
index 000000000..b531d31de
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "topoMapper.H"
+#include "topoCellMapper.H"
+#include "topoSurfaceMapper.H"
+#include "topoBoundaryMeshMapper.H"
+
+namespace Foam
+{
+
+// Conservatively map all volFields in the registry
+template <class Type>
+void conservativeMapVolFields(const topoMapper& mapper)
+{
+    // Define a few typedefs for convenience
+    typedef typename outerProduct<vector, Type>::type gCmptType;
+    typedef GeometricField<Type, fvPatchField, volMesh> volType;
+    typedef GeometricField<gCmptType, fvPatchField, volMesh> gradVolType;
+
+    HashTable<const volType*> fields(mapper.mesh().lookupClass<volType>());
+
+    // Store old-times before mapping
+    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        fIter()->storeOldTimes();
+    }
+
+    // Fetch internal/boundary mappers
+    const topoCellMapper& fMap = mapper.volMap();
+    const topoBoundaryMeshMapper& bMap = mapper.boundaryMap();
+
+    // Now map all fields
+    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        volType& field = const_cast<volType&>(*fIter());
+
+        if (fvMesh::debug)
+        {
+            Info<< "Conservatively mapping "
+                << field.typeName
+                << ' ' << field.name()
+                << endl;
+        }
+
+        // Map the internal field
+        fMap.mapInternalField
+        (
+            field.name(),
+            mapper.gradient<gradVolType>(field.name()).internalField(),
+            field.internalField()
+        );
+
+        // Map patch fields
+        forAll(bMap, patchI)
+        {
+            bMap[patchI].mapPatchField
+            (
+                field.name(),
+                field.boundaryField()[patchI]
+            );
+        }
+
+        // Set the field instance
+        field.instance() = field.mesh().thisDb().time().timeName();
+    }
+}
+
+
+// Conservatively map all surfaceFields in the registry
+template <class Type>
+void conservativeMapSurfaceFields(const topoMapper& mapper)
+{
+    // Define a few typedefs for convenience
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfType;
+
+    HashTable<const surfType*> fields(mapper.mesh().lookupClass<surfType>());
+
+    // Store old-times before mapping
+    forAllIter(typename HashTable<const surfType*>, fields, fIter)
+    {
+        fIter()->storeOldTimes();
+    }
+
+    // Fetch internal/boundary mappers
+    const topoSurfaceMapper& fMap = mapper.surfaceMap();
+    const topoBoundaryMeshMapper& bMap = mapper.boundaryMap();
+
+    // Now map all fields
+    forAllIter(typename HashTable<const surfType*>, fields, fIter)
+    {
+        surfType& field = const_cast<surfType&>(*fIter());
+
+        if (fvMesh::debug)
+        {
+            Info<< "Conservatively mapping "
+                << field.typeName
+                << ' ' << field.name()
+                << endl;
+        }
+
+        // Map the internal field
+        fMap.mapInternalField
+        (
+            field.name(),
+            field.internalField()
+        );
+
+        // Map patch fields
+        forAll(bMap, patchI)
+        {
+            bMap[patchI].mapPatchField
+            (
+                field.name(),
+                field.boundaryField()[patchI]
+            );
+        }
+
+        // Set the field instance
+        field.instance() = field.mesh().thisDb().time().timeName();
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
index e7c0dba9f..fe61072ae 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
@@ -33,7 +33,7 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 #include "fluxCorrector.H"
 #include "dlLibraryTable.H"
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H
index f80ca0cc2..61e11009e 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H
@@ -49,8 +49,6 @@ SourceFiles
 namespace Foam
 {
 
-// Forward class declarations
-
 /*---------------------------------------------------------------------------*\
                          Class fluxCorrector Declaration
 \*---------------------------------------------------------------------------*/
@@ -142,10 +140,6 @@ public:
 
 } // End namespace Foam
 
-#ifdef NoRepository
-#include "fluxCorrector.C"
-#endif
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C
index 7535964b4..3eb0a5c0a 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C
@@ -33,9 +33,8 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
-#include "IOmanip.H"
 #include "topoMapper.H"
 #include "mapPolyMesh.H"
 #include "topoCellMapper.H"
@@ -306,6 +305,7 @@ const List<vectorField>& topoCellMapper::intersectionCentres() const
     return *centresPtr_;
 }
 
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 // Construct from components
@@ -319,6 +319,7 @@ topoCellMapper::topoCellMapper
     mpm_(mpm),
     tMapper_(mapper),
     direct_(false),
+    sizeBeforeMapping_(mpm.nOldCells()),
     directAddrPtr_(NULL),
     interpolationAddrPtr_(NULL),
     weightsPtr_(NULL),
@@ -326,6 +327,18 @@ topoCellMapper::topoCellMapper
     volumesPtr_(NULL),
     centresPtr_(NULL)
 {
+    // Fetch offset sizes from topoMapper
+    const labelList& sizes = tMapper_.cellSizes();
+
+    // Add offset sizes
+    if (sizes.size())
+    {
+        forAll(sizes, pI)
+        {
+            sizeBeforeMapping_ += sizes[pI];
+        }
+    }
+
     // Check for possibility of direct mapping
     if
     (
@@ -363,7 +376,7 @@ label topoCellMapper::size() const
 //- Return size before mapping
 label topoCellMapper::sizeBeforeMapping() const
 {
-    return mpm_.nOldCells();
+    return sizeBeforeMapping_;
 }
 
 
@@ -459,99 +472,6 @@ const labelList& topoCellMapper::insertedObjectLabels() const
 }
 
 
-//- Conservatively map the internal field
-template <class Type, class gradType>
-void topoCellMapper::mapInternalField
-(
-    const word& fieldName,
-    const Field<gradType>& gF,
-    Field<Type>& iF
-) const
-{
-    if (iF.size() != sizeBeforeMapping() || gF.size() != sizeBeforeMapping())
-    {
-        FatalErrorIn
-        (
-            "\n\n"
-            "void topoCellMapper::mapInternalField<Type>\n"
-            "(\n"
-            "    const word& fieldName,\n"
-            "    const Field<gradType>& gF,\n"
-            "    Field<Type>& iF\n"
-            ") const\n"
-        )  << "Incompatible size before mapping." << nl
-           << " Field: " << fieldName << nl
-           << " Field size: " << iF.size() << nl
-           << " Gradient Field size: " << gF.size() << nl
-           << " map size: " << sizeBeforeMapping() << nl
-           << abort(FatalError);
-    }
-
-    // Fetch addressing
-    const labelListList& cAddressing = addressing();
-    const List<scalarField>& wC = intersectionWeights();
-    const List<vectorField>& xC = intersectionCentres();
-
-    // Fetch geometry
-    const vectorField& centres = tMapper_.internalCentres();
-
-    // Compute the integral of the source field
-    Type intSource = sum(iF * tMapper_.cellVolumes());
-
-    // Copy the original field
-    Field<Type> fieldCpy(iF);
-
-    // Resize to current dimensions
-    iF.setSize(size());
-
-    // Map the internal field
-    forAll(iF, cellI)
-    {
-        const labelList& addr = cAddressing[cellI];
-
-        iF[cellI] = pTraits<Type>::zero;
-
-        forAll(addr, cellJ)
-        {
-            // Accumulate volume-weighted Taylor-series interpolate
-            iF[cellI] +=
-            (
-                wC[cellI][cellJ] *
-                (
-                    fieldCpy[addr[cellJ]]
-                  + (
-                        gF[addr[cellJ]] &
-                        (
-                            xC[cellI][cellJ]
-                          - centres[addr[cellJ]]
-                        )
-                    )
-                )
-            );
-        }
-    }
-
-    // Compute the integral of the target field
-    Type intTarget = sum(iF * mesh_.cellVolumes());
-
-    if (polyMesh::debug)
-    {
-        int oldP = Info().precision();
-
-        // Compare the global integral
-        Info << " Field : " << fieldName
-             << " integral errors : "
-             << setprecision(15)
-             << " source : " << mag(intSource)
-             << " target : " << mag(intTarget)
-             << " norm : "
-             << (mag(intTarget - intSource) / (mag(intSource) + VSMALL))
-             << setprecision(oldP)
-             << endl;
-    }
-}
-
-
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 void topoCellMapper::operator=(const topoCellMapper& rhs)
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H
index 725937998..5aac46b98 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H
@@ -43,6 +43,7 @@ SourceFiles
 #ifndef topoCellMapper_H
 #define topoCellMapper_H
 
+#include "topoMapper.H"
 #include "morphFieldMapper.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -50,10 +51,6 @@ SourceFiles
 namespace Foam
 {
 
-// Class forward declarations
-class topoMapper;
-class mapPolyMesh;
-
 /*---------------------------------------------------------------------------*\
                         Class topoCellMapper Declaration
 \*---------------------------------------------------------------------------*/
@@ -76,6 +73,9 @@ class topoCellMapper
         //- Is the mapping direct
         bool direct_;
 
+        //- Size before mapping
+        mutable label sizeBeforeMapping_;
+
     // Demand-driven private data
 
         //- Direct addressing
@@ -178,9 +178,12 @@ public:
 
 } // End namespace Foam
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #ifdef NoRepository
-#    include "topoCellMapper.C"
+#   include "topoCellMapperTemplates.C"
 #endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapperTemplates.C
new file mode 100644
index 000000000..45eee641f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapperTemplates.C
@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Conservatively map the internal field
+template <class Type, class gradType>
+void topoCellMapper::mapInternalField
+(
+    const word& fieldName,
+    const Field<gradType>& gF,
+    Field<Type>& iF
+) const
+{
+    if (iF.size() != sizeBeforeMapping() || gF.size() != sizeBeforeMapping())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "void topoCellMapper::mapInternalField<Type>\n"
+            "(\n"
+            "    const word& fieldName,\n"
+            "    const Field<gradType>& gF,\n"
+            "    Field<Type>& iF\n"
+            ") const\n"
+        )  << "Incompatible size before mapping." << nl
+           << " Field: " << fieldName << nl
+           << " Field size: " << iF.size() << nl
+           << " Gradient Field size: " << gF.size() << nl
+           << " map size: " << sizeBeforeMapping() << nl
+           << abort(FatalError);
+    }
+
+    // If we have direct addressing, map and bail out
+    if (direct())
+    {
+        iF.autoMap(*this);
+        return;
+    }
+
+    // Fetch addressing
+    const labelListList& cAddressing = addressing();
+    const List<scalarField>& wC = intersectionWeights();
+    const List<vectorField>& xC = intersectionCentres();
+
+    // Fetch geometry
+    const vectorField& centres = tMapper_.internalCentres();
+
+    // Copy the original field
+    Field<Type> fieldCpy(iF);
+
+    // Resize to current dimensions
+    iF.setSize(size());
+
+    // Map the internal field
+    forAll(iF, cellI)
+    {
+        const labelList& addr = cAddressing[cellI];
+
+        iF[cellI] = pTraits<Type>::zero;
+
+        forAll(addr, cellJ)
+        {
+            // Accumulate volume-weighted Taylor-series interpolate
+            iF[cellI] +=
+            (
+                wC[cellI][cellJ] *
+                (
+                    fieldCpy[addr[cellJ]]
+                  + (
+                        gF[addr[cellJ]] &
+                        (
+                            xC[cellI][cellJ]
+                          - centres[addr[cellJ]]
+                        )
+                    )
+                )
+            );
+        }
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
index 3d69a78a1..ab69e2666 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
@@ -35,120 +35,18 @@ Author
 
 \*----------------------------------------------------------------------------*/
 
-#include "fvc.H"
 #include "topoMapper.H"
 #include "fluxCorrector.H"
 #include "topoCellMapper.H"
-#include "leastSquaresGrad.H"
 #include "topoSurfaceMapper.H"
 #include "topoBoundaryMeshMapper.H"
+#include "fixedValueFvPatchFields.H"
 
 namespace Foam
 {
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Store gradients of fields on the mesh prior to topology changes
-template <class Type, class gradType>
-void topoMapper::storeGradients
-(
-    HashTable<autoPtr<gradType> >& gradTable
-) const
-{
-    // Define a few typedefs for convenience
-    typedef typename outerProduct<vector, Type>::type gCmptType;
-    typedef GeometricField<Type, fvPatchField, volMesh> volType;
-    typedef GeometricField<gCmptType, fvPatchField, volMesh> gVolType;
-
-    // Fetch all fields from registry
-    HashTable<const volType*> fields
-    (
-        mesh_.objectRegistry::lookupClass<volType>()
-    );
-
-    forAllConstIter(typename HashTable<const volType*>, fields, fIter)
-    {
-        const volType& field = *fIter();
-
-        // Compute the gradient.
-        tmp<gVolType> tGrad;
-
-        // If the fvSolution dictionary contains an entry,
-        // use that, otherwise, default to leastSquares
-        word gradName("grad(" + field.name() + ')');
-
-        if (mesh_.schemesDict().subDict("gradSchemes").found(gradName))
-        {
-            tGrad = fvc::grad(field);
-        }
-        else
-        {
-            tGrad = fv::leastSquaresGrad<Type>(mesh_).grad(field);
-        }
-
-        // Make a new entry, but don't register the field.
-        gradTable.insert
-        (
-            field.name(),
-            autoPtr<gradType>
-            (
-                new gradType
-                (
-                    IOobject
-                    (
-                        tGrad().name(),
-                        mesh_.time().timeName(),
-                        mesh_,
-                        IOobject::NO_READ,
-                        IOobject::NO_WRITE,
-                        false
-                    ),
-                    tGrad()
-                )
-            )
-        );
-    }
-}
-
-
-//- Fetch the gradient field (template specialisation)
-template <>
-const volVectorField& topoMapper::gradient(const word& name) const
-{
-    if (!sGrads_.found(name))
-    {
-        FatalErrorIn
-        (
-            "const volVectorField& "
-            "topoMapper::gradient(const word& name) const"
-        ) << nl << " Gradient for: " << name
-          << " has not been stored."
-          << abort(FatalError);
-    }
-
-    return sGrads_[name]();
-}
-
-
-//- Fetch the gradient field (template specialisation)
-template <>
-const volTensorField& topoMapper::gradient(const word& name) const
-{
-    if (!vGrads_.found(name))
-    {
-        FatalErrorIn
-        (
-            "const volTensorField& "
-            "topoMapper::gradient(const word& name) const"
-        ) << nl << " Gradient for: " << name
-          << " has not been stored."
-          << abort(FatalError);
-    }
-
-    return vGrads_[name]();
-}
-
-
 //- Store gradients prior to mesh reset
 void topoMapper::storeGradients() const
 {
@@ -157,11 +55,8 @@ void topoMapper::storeGradients() const
 
     if (fvMesh::debug)
     {
-        Info << "Registered volScalarFields: " << endl;
-        Info << sGrads_.toc() << endl;
-
-        Info << "Registered volVectorFields: " << endl;
-        Info << vGrads_.toc() << endl;
+        Info<< "Registered volScalarFields: " << scalarGrads() << endl;
+        Info<< "Registered volVectorFields: " << vectorGrads() << endl;
     }
 }
 
@@ -169,52 +64,78 @@ void topoMapper::storeGradients() const
 //- Store geometric information
 void topoMapper::storeGeometry() const
 {
-    if (cellCentresPtr_)
+    // Wipe out existing information
+    deleteDemandDrivenData(cellCentresPtr_);
+
+    vectorField Cv(mesh_.cellCentres());
+    vectorField Cf(mesh_.faceCentres());
+
+    // Create and map the patch field values
+    label nPatches = mesh_.boundary().size();
+
+    // Create field parts
+    PtrList<fvPatchField<vector> > volCentrePatches(nPatches);
+
+    // Over-ride and set all patches to fixedValue
+    for (label patchI = 0; patchI < nPatches; patchI++)
     {
-        deleteDemandDrivenData(cellVolumesPtr_);
-        deleteDemandDrivenData(cellCentresPtr_);
+        volCentrePatches.set
+        (
+            patchI,
+            new fixedValueFvPatchField<vector>
+            (
+                mesh_.boundary()[patchI],
+                DimensionedField<vector, volMesh>::null()
+            )
+        );
 
-        patchAreasPtr_.clear();
-        patchCentresPtr_.clear();
+        // Slice field to patch (forced assignment)
+        volCentrePatches[patchI] ==
+        (
+            mesh_.boundaryMesh()[patchI].patchSlice(Cf)
+        );
     }
 
-    // Set the cell-volumes pointer.
-    cellVolumesPtr_ = new scalarField(mesh_.cellVolumes());
-
     // Set the cell-centres pointer.
-    cellCentresPtr_ = new vectorField(mesh_.cellCentres());
-
-    // Set patch-areas
-    patchAreasPtr_.setSize(mesh_.boundaryMesh().size());
-
-    forAll(mesh_.boundaryMesh(), patchI)
-    {
-        patchAreasPtr_.set
+    cellCentresPtr_ =
+    (
+        new volVectorField
         (
-            patchI,
-            new scalarField
+            IOobject
             (
-                mag(mesh_.boundaryMesh()[patchI].faceAreas())
-            )
-        );
-    }
-
-    // Set patch-centres.
-    patchCentresPtr_.setSize(mesh_.boundaryMesh().size());
-
-    forAll(mesh_.boundaryMesh(), patchI)
-    {
-        patchCentresPtr_.set
-        (
-            patchI,
-            new vectorField
-            (
-                mesh_.boundaryMesh()[patchI].faceCentres()
-            )
-        );
-    }
+                "cellCentres",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            mesh_,
+            dimLength,
+            SubField<vector>(Cv, mesh_.nCells()),
+            volCentrePatches
+        )
+    );
 }
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+//- Construct from mesh and dictionary
+topoMapper::topoMapper
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+:
+    mesh_(mesh),
+    dict_(dict),
+    cellMap_(NULL),
+    surfaceMap_(NULL),
+    boundaryMap_(NULL),
+    fluxCorrector_(fluxCorrector::New(mesh, dict)),
+    cellCentresPtr_(NULL)
+{}
+
 
 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * *  //
 
@@ -287,6 +208,26 @@ void topoMapper::setCellWeights
 }
 
 
+//- Set cell / patch offset information
+void topoMapper::setOffsets
+(
+    const labelList& cellSizes,
+    const labelList& cellStarts,
+    const labelList& faceSizes,
+    const labelList& faceStarts,
+    const labelListList& patchSizes,
+    const labelListList& patchStarts
+) const
+{
+    cellSizes_ = cellSizes;
+    cellStarts_ = cellStarts;
+    faceSizes_ = faceSizes;
+    faceStarts_ = faceStarts;
+    patchSizes_ = patchSizes;
+    patchStarts_ = patchStarts;
+}
+
+
 //- Fetch face weights
 const List<scalarField>& topoMapper::faceWeights() const
 {
@@ -315,6 +256,48 @@ const List<vectorField>& topoMapper::cellCentres() const
 }
 
 
+//- Fetch cell sizes
+const labelList& topoMapper::cellSizes() const
+{
+    return cellSizes_;
+}
+
+
+//- Fetch face sizes
+const labelList& topoMapper::faceSizes() const
+{
+    return faceSizes_;
+}
+
+
+//- Fetch patch sizes
+const labelListList& topoMapper::patchSizes() const
+{
+    return patchSizes_;
+}
+
+
+//- Fetch cell starts
+const labelList& topoMapper::cellStarts() const
+{
+    return cellStarts_;
+}
+
+
+//- Fetch face starts
+const labelList& topoMapper::faceStarts() const
+{
+    return faceStarts_;
+}
+
+
+//- Fetch patch starts
+const labelListList& topoMapper::patchStarts() const
+{
+    return patchStarts_;
+}
+
+
 //- Store mesh information for the mapping stage
 void topoMapper::storeMeshInformation() const
 {
@@ -325,20 +308,19 @@ void topoMapper::storeMeshInformation() const
     storeGeometry();
 }
 
-
-//- Return stored cell volume information
-const scalarField& topoMapper::cellVolumes() const
+//- Return non-const access to cell centres
+volVectorField& topoMapper::volCentres() const
 {
-    if (!cellVolumesPtr_)
+    if (!cellCentresPtr_)
     {
         FatalErrorIn
         (
-            "const scalarField& topoMapper::cellVolumes()"
+            "const vectorField& topoMapper::volCentres() const"
         ) << nl << " Pointer has not been set. "
           << abort(FatalError);
     }
 
-    return *cellVolumesPtr_;
+    return *cellCentresPtr_;
 }
 
 
@@ -349,7 +331,7 @@ const vectorField& topoMapper::internalCentres() const
     {
         FatalErrorIn
         (
-            "const vectorField& topoMapper::internalCentres()"
+            "const vectorField& topoMapper::internalCentres() const"
         ) << nl << " Pointer has not been set. "
           << abort(FatalError);
     }
@@ -358,154 +340,70 @@ const vectorField& topoMapper::internalCentres() const
 }
 
 
-//- Return stored patch areas information
-const scalarField& topoMapper::patchAreas(const label i) const
-{
-    if (!patchAreasPtr_.set(i))
-    {
-        FatalErrorIn
-        (
-            "const scalarField& topoMapper::patchAreas"
-            "(const label i) const"
-        ) << nl << " Pointer has not been set at index: " << i
-          << abort(FatalError);
-    }
-
-    return patchAreasPtr_[i];
-}
-
-
 //- Return stored patch centre information
 const vectorField& topoMapper::patchCentres(const label i) const
 {
-    if (!patchCentresPtr_.set(i))
+    if (!cellCentresPtr_)
     {
         FatalErrorIn
         (
             "const vectorField& topoMapper::patchCentres"
             "(const label i) const"
-        ) << nl << " Pointer has not been set at index: " << i
+        ) << nl << " Pointer has not been set. index: " << i
           << abort(FatalError);
     }
 
-    return patchCentresPtr_[i];
+    return (*cellCentresPtr_).boundaryField()[i];
 }
 
 
-// Conservatively map all volFields in the registry
-template <class Type>
-void topoMapper::conservativeMapVolFields() const
+//- Return names of stored scalar gradients
+const wordList topoMapper::scalarGrads() const
 {
-    // Define a few typedefs for convenience
-    typedef typename outerProduct<vector, Type>::type gCmptType;
-    typedef GeometricField<Type, fvPatchField, volMesh> volType;
-    typedef GeometricField<gCmptType, fvPatchField, volMesh> gradVolType;
-
-    HashTable<const volType*> fields(mesh_.lookupClass<volType>());
-
-    // Store old-times before mapping
-    forAllIter(typename HashTable<const volType*>, fields, fIter)
-    {
-        volType& field = const_cast<volType&>(*fIter());
-
-        field.storeOldTimes();
-    }
-
-    // Fetch internal/boundary mappers
-    const topoCellMapper& fMap = volMap();
-    const topoBoundaryMeshMapper& bMap = boundaryMap();
-
-    // Now map all fields
-    forAllIter(typename HashTable<const volType*>, fields, fIter)
-    {
-        volType& field = const_cast<volType&>(*fIter());
-
-        if (fvMesh::debug)
-        {
-            Info << "Conservatively mapping "
-                 << field.typeName
-                 << ' ' << field.name()
-                 << endl;
-        }
-
-        // Map the internal field
-        fMap.mapInternalField
-        (
-            field.name(),
-            gradient<gradVolType>(field.name()).internalField(),
-            field.internalField()
-        );
-
-        // Map patch fields
-        forAll(bMap, patchI)
-        {
-            bMap[patchI].mapPatchField
-            (
-                field.name(),
-                field.boundaryField()[patchI]
-            );
-        }
-
-        // Set the field instance
-        field.instance() = field.mesh().thisDb().time().timeName();
-    }
+    return sGrads_.toc();
 }
 
 
-// Conservatively map all surfaceFields in the registry
-template <class Type>
-void topoMapper::conservativeMapSurfaceFields() const
+//- Return names of stored vector gradients
+const wordList topoMapper::vectorGrads() const
 {
-    // Define a few typedefs for convenience
-    typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfType;
+    return vGrads_.toc();
+}
 
-    HashTable<const surfType*> fields(mesh_.lookupClass<surfType>());
 
-    // Store old-times before mapping
-    forAllIter(typename HashTable<const surfType*>, fields, fIter)
+//- Fetch the gradient field (template specialisation)
+template <>
+volVectorField& topoMapper::gradient(const word& name) const
+{
+    if (!sGrads_.found(name))
     {
-        surfType& field = const_cast<surfType&>(*fIter());
-
-        field.storeOldTimes();
-    }
-
-    // Fetch internal/boundary mappers
-    const topoSurfaceMapper& fMap = surfaceMap();
-    const topoBoundaryMeshMapper& bMap = boundaryMap();
-
-    // Now map all fields
-    forAllIter(typename HashTable<const surfType*>, fields, fIter)
-    {
-        surfType& field = const_cast<surfType&>(*fIter());
-
-        if (fvMesh::debug)
-        {
-            Info << "Conservatively mapping "
-                 << field.typeName
-                 << ' ' << field.name()
-                 << endl;
-        }
-
-        // Map the internal field
-        fMap.mapInternalField
+        FatalErrorIn
         (
-            field.name(),
-            field.internalField()
-        );
-
-        // Map patch fields
-        forAll(bMap, patchI)
-        {
-            bMap[patchI].mapPatchField
-            (
-                field.name(),
-                field.boundaryField()[patchI]
-            );
-        }
-
-        // Set the field instance
-        field.instance() = field.mesh().thisDb().time().timeName();
+            "volVectorField& topoMapper::gradient(const word& name) const"
+        ) << nl << " Gradient for: " << name
+          << " has not been stored."
+          << abort(FatalError);
     }
+
+    return sGrads_[name]();
+}
+
+
+//- Fetch the gradient field (template specialisation)
+template <>
+volTensorField& topoMapper::gradient(const word& name) const
+{
+    if (!vGrads_.found(name))
+    {
+        FatalErrorIn
+        (
+            "volTensorField& topoMapper::gradient(const word& name) const"
+        ) << nl << " Gradient for: " << name
+          << " has not been stored."
+          << abort(FatalError);
+    }
+
+    return vGrads_[name]();
 }
 
 
@@ -533,7 +431,7 @@ const topoCellMapper& topoMapper::volMap() const
     {
         FatalErrorIn
         (
-            "const topoCellMapper& topoMapper::volMap()"
+            "const topoCellMapper& topoMapper::volMap() const"
         ) << nl << " Volume mapper has not been set. "
           << abort(FatalError);
     }
@@ -549,7 +447,7 @@ const topoSurfaceMapper& topoMapper::surfaceMap() const
     {
         FatalErrorIn
         (
-            "const topoSurfaceMapper& topoMapper::surfaceMap()"
+            "const topoSurfaceMapper& topoMapper::surfaceMap() const"
         ) << nl << " Surface mapper has not been set. "
           << abort(FatalError);
     }
@@ -565,7 +463,7 @@ const topoBoundaryMeshMapper& topoMapper::boundaryMap() const
     {
         FatalErrorIn
         (
-            "const topoBoundaryMeshMapper& topoMapper::boundaryMap()"
+            "const topoBoundaryMeshMapper& topoMapper::boundaryMap() const"
         ) << nl << " Boundary mapper has not been set. "
           << abort(FatalError);
     }
@@ -581,7 +479,7 @@ const fluxCorrector& topoMapper::surfaceFluxCorrector() const
     {
         FatalErrorIn
         (
-            "const fluxCorrector& topoMapper::surfaceFluxCorrector()"
+            "const fluxCorrector& topoMapper::surfaceFluxCorrector() const"
         ) << nl << " fluxCorrector has not been set. "
           << abort(FatalError);
     }
@@ -591,7 +489,7 @@ const fluxCorrector& topoMapper::surfaceFluxCorrector() const
 
 
 //- Clear out member data
-void topoMapper::clear()
+void topoMapper::clear() const
 {
     // Clear out mappers
     cellMap_.clear();
@@ -603,10 +501,7 @@ void topoMapper::clear()
     vGrads_.clear();
 
     // Wipe out geomtry information
-    deleteDemandDrivenData(cellVolumesPtr_);
     deleteDemandDrivenData(cellCentresPtr_);
-    patchAreasPtr_.clear();
-    patchCentresPtr_.clear();
 
     // Clear maps
     faceWeights_.clear();
@@ -614,6 +509,16 @@ void topoMapper::clear()
 
     faceCentres_.clear();
     cellCentres_.clear();
+
+    // Clear sizes / offsets
+    cellSizes_.clear();
+    cellStarts_.clear();
+
+    faceSizes_.clear();
+    faceStarts_.clear();
+
+    patchSizes_.clear();
+    patchStarts_.clear();
 }
 
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
index 67fd83ddc..00b508e6a 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
@@ -42,7 +42,9 @@ SourceFiles
 #ifndef topoMapper_H
 #define topoMapper_H
 
-#include "fluxCorrector.H"
+#include "autoPtr.H"
+#include "IOmanip.H"
+#include "volFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -50,10 +52,10 @@ namespace Foam
 {
 
 // Class forward declarations
+class fluxCorrector;
 class topoCellMapper;
 class topoSurfaceMapper;
 class topoBoundaryMeshMapper;
-class mapPolyMesh;
 
 /*---------------------------------------------------------------------------*\
                          Class topoMapper Declaration
@@ -88,19 +90,24 @@ class topoMapper
         mutable HashTable<autoPtr<volTensorField> > vGrads_;
 
         //- Geometric information on the old mesh
-        mutable scalarField* cellVolumesPtr_;
-        mutable vectorField* cellCentresPtr_;
-        mutable PtrList<scalarField> patchAreasPtr_;
-        mutable PtrList<vectorField> patchCentresPtr_;
+        mutable volVectorField* cellCentresPtr_;
 
-        //- Intersection volume weights
+        //- Intersection weights
         mutable List<scalarField> faceWeights_;
         mutable List<scalarField> cellWeights_;
 
-        //- Intersection centre weights
+        //- Intersection centres
         mutable List<vectorField> faceCentres_;
         mutable List<vectorField> cellCentres_;
 
+        //- Sizes / starts for mapping
+        mutable labelList cellSizes_;
+        mutable labelList cellStarts_;
+        mutable labelList faceSizes_;
+        mutable labelList faceStarts_;
+        mutable labelListList patchSizes_;
+        mutable labelListList patchStarts_;
+
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
@@ -117,10 +124,6 @@ class topoMapper
             HashTable<autoPtr<gradType> >& gradTable
         ) const;
 
-        //- Fetch the gradient field
-        template <class Type>
-        const Type& gradient(const word& name) const;
-
         //- Store gradients prior to mesh reset
         void storeGradients() const;
 
@@ -132,19 +135,7 @@ public:
     // Constructors
 
         //- Construct from mesh and dictionary
-        topoMapper(const fvMesh& mesh, const dictionary& dict)
-        :
-            mesh_(mesh),
-            dict_(dict),
-            cellMap_(NULL),
-            surfaceMap_(NULL),
-            boundaryMap_(NULL),
-            fluxCorrector_(fluxCorrector::New(mesh, dict)),
-            cellVolumesPtr_(NULL),
-            cellCentresPtr_(NULL),
-            patchAreasPtr_(mesh.boundary().size()),
-            patchCentresPtr_(mesh.boundary().size())
-        {}
+        topoMapper(const fvMesh& mesh, const dictionary& dict);
 
     // Destructor
 
@@ -175,6 +166,17 @@ public:
             const Xfer<List<vectorField> >& centres
         ) const;
 
+        //- Set cell / patch offset information
+        void setOffsets
+        (
+            const labelList& cellSizes,
+            const labelList& cellStarts,
+            const labelList& faceSizes,
+            const labelList& faceStarts,
+            const labelListList& patchSizes,
+            const labelListList& patchStarts
+        ) const;
+
         //- Fetch face weights
         const List<scalarField>& faceWeights() const;
 
@@ -187,28 +189,45 @@ public:
         //- Fetch cell centres
         const List<vectorField>& cellCentres() const;
 
+        //- Fetch cell sizes
+        const labelList& cellSizes() const;
+
+        //- Fetch face sizes
+        const labelList& faceSizes() const;
+
+        //- Fetch patch sizes
+        const labelListList& patchSizes() const;
+
+        //- Fetch cell starts
+        const labelList& cellStarts() const;
+
+        //- Fetch face starts
+        const labelList& faceStarts() const;
+
+        //- Fetch patch starts
+        const labelListList& patchStarts() const;
+
         //- Store mesh information for the mapping stage
         void storeMeshInformation() const;
 
-        //- Return stored cell volume information
-        const scalarField& cellVolumes() const;
+        //- Return non-const access to cell centres
+        volVectorField& volCentres() const;
 
         //- Return stored cell centre information
         const vectorField& internalCentres() const;
 
-        //- Return stored patch area information
-        const scalarField& patchAreas(const label i) const;
-
         //- Return stored patch centre information
         const vectorField& patchCentres(const label i) const;
 
-        // Conservatively map all volFields in the registry
-        template <class Type>
-        void conservativeMapVolFields() const;
+        //- Return names of stored scalar gradients
+        const wordList scalarGrads() const;
 
-        // Conservatively map all surfaceFields in the registry
+        //- Return names of stored vector gradients
+        const wordList vectorGrads() const;
+
+        //- Fetch the gradient field
         template <class Type>
-        void conservativeMapSurfaceFields() const;
+        Type& gradient(const word& name) const;
 
         //- Correct fluxes after topology change
         void correctFluxes() const;
@@ -226,7 +245,7 @@ public:
         const fluxCorrector& surfaceFluxCorrector() const;
 
         //- Clear out member data
-        void clear();
+        void clear() const;
 };
 
 
@@ -234,8 +253,10 @@ public:
 
 } // End namespace Foam
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #ifdef NoRepository
-#include "topoMapper.C"
+#   include "topoMapperTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
new file mode 100644
index 000000000..8082b0070
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvc.H"
+#include "leastSquaresGrad.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Store gradients of fields on the mesh prior to topology changes
+template <class Type, class gradType>
+void topoMapper::storeGradients
+(
+    HashTable<autoPtr<gradType> >& gradTable
+) const
+{
+    // Define a few typedefs for convenience
+    typedef typename outerProduct<vector, Type>::type gCmptType;
+    typedef GeometricField<Type, fvPatchField, volMesh> volType;
+    typedef GeometricField<gCmptType, fvPatchField, volMesh> gVolType;
+
+    // Fetch all fields from registry
+    HashTable<const volType*> fields
+    (
+        mesh_.objectRegistry::lookupClass<volType>()
+    );
+
+    // Store old-times before gradient computation
+    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        fIter()->storeOldTimes();
+    }
+
+    forAllConstIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        const volType& field = *fIter();
+
+        // Compute the gradient.
+        tmp<gVolType> tGrad;
+
+        // If the fvSolution dictionary contains an entry,
+        // use that, otherwise, default to leastSquares
+        word gradName("grad(" + field.name() + ')');
+
+        if (mesh_.schemesDict().subDict("gradSchemes").found(gradName))
+        {
+            tGrad = fvc::grad(field);
+        }
+        else
+        {
+            tGrad = fv::leastSquaresGrad<Type>(mesh_).grad(field);
+        }
+
+        // Make a new entry, but don't register the field.
+        gradTable.insert
+        (
+            field.name(),
+            autoPtr<gradType>
+            (
+                new gradType
+                (
+                    IOobject
+                    (
+                        tGrad().name(),
+                        mesh_.time().timeName(),
+                        mesh_,
+                        IOobject::NO_READ,
+                        IOobject::NO_WRITE,
+                        false
+                    ),
+                    tGrad()
+                )
+            )
+        );
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
index fcc3c9e1d..98da872bb 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
@@ -33,9 +33,10 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 #include "IOmanip.H"
+#include "meshOps.H"
 #include "topoMapper.H"
 #include "mapPolyMesh.H"
 #include "topoPatchMapper.H"
@@ -73,9 +74,17 @@ void topoPatchMapper::calcInsertedFaceAddressing() const
     }
 
     // Information from the old patch
-    const label oldPatchSize = mpm_.oldPatchSizes()[patch_.index()];
+    const label oldPatchSize = sizeBeforeMapping();
     const label oldPatchStart = mpm_.oldPatchStarts()[patch_.index()];
-    const label oldPatchEnd = oldPatchStart + oldPatchSize;
+
+    if (oldPatchSize == 0)
+    {
+        // Nothing to map from. Return empty.
+        insertedFaceLabelsPtr_ = new labelList(0);
+        insertedFaceIndexMapPtr_ = new labelList(0);
+        insertedFaceAddressingPtr_ = new labelListList(0);
+        return;
+    }
 
     // Allocate for inserted face labels and addressing
     label nInsertedFaces = 0;
@@ -108,6 +117,19 @@ void topoPatchMapper::calcInsertedFaceAddressing() const
         {
             if (fffI.masterObjects().empty())
             {
+                // Write out for post-processing
+                meshOps::writeVTK
+                (
+                    mpm_.mesh(),
+                    "patchFaceInsError_"
+                  + Foam::name(fffI.index()),
+                    labelList(1, fffI.index()),
+                    2,
+                    mpm_.mesh().points(),
+                    List<edge>(0),
+                    mpm_.mesh().faces()
+                );
+
                 FatalErrorIn
                 (
                     "void topoPatchMapper::"
@@ -130,23 +152,26 @@ void topoPatchMapper::calcInsertedFaceAddressing() const
                 // Make an entry for addressing
                 labelList& addr = insertedAddressing[nInsertedFaces];
 
-                // Renumber addressing to patch.
-                // Also, check mapping for hits into
-                // other patches / internal faces.
+                // Check for illegal addressing
                 addr = fffI.masterObjects();
 
                 forAll(addr, faceI)
                 {
-                    if
-                    (
-                        addr[faceI] >= oldPatchStart
-                     && addr[faceI] < oldPatchEnd
-                    )
-                    {
-                        addr[faceI] -= oldPatchStart;
-                    }
-                    else
+                    if (addr[faceI] < 0 || addr[faceI] >= oldPatchSize)
                     {
+                        // Write out for post-processing
+                        meshOps::writeVTK
+                        (
+                            mpm_.mesh(),
+                            "patchFacePatchError_"
+                          + Foam::name(fffI.index()),
+                            labelList(1, fffI.index()),
+                            2,
+                            mpm_.mesh().points(),
+                            List<edge>(0),
+                            mpm_.mesh().faces()
+                        );
+
                         FatalErrorIn
                         (
                             "void topoPatchMapper::"
@@ -154,10 +179,13 @@ void topoPatchMapper::calcInsertedFaceAddressing() const
                         )
                             << "Addressing into another patch is not allowed."
                             << nl << " Patch face index: " << faceI
+                            << nl << " Patch: " << patch_.name()
+                            << nl << " fffI.index: " << fffI.index()
+                            << nl << " pStart: " << pStart
+                            << nl << " addr: " << addr
                             << nl << " addr[faceI]: " << addr[faceI]
                             << nl << " oldPatchStart: " << oldPatchStart
                             << nl << " oldPatchSize: " << oldPatchSize
-                            << nl << " oldPatchEnd: " << oldPatchEnd
                             << abort(FatalError);
                     }
                 }
@@ -185,21 +213,31 @@ void topoPatchMapper::calcAddressing() const
     }
 
     // Information from the old patch
-    const label oldPatchSize = mpm_.oldPatchSizes()[patch_.index()];
+    const label oldPatchSize = sizeBeforeMapping();
     const label oldPatchStart = mpm_.oldPatchStarts()[patch_.index()];
     const label oldPatchEnd = oldPatchStart + oldPatchSize;
 
     // Assemble the maps: slice to patch
     if (direct())
     {
+        if (oldPatchSize == 0)
+        {
+            // Nothing to map from. Return empty.
+            directAddrPtr_ = new labelList(0);
+            return;
+        }
+
         // Direct mapping - slice to size
-        directAddrPtr_ = new labelList(patch_.patch().patchSlice(mpm_.faceMap()));
+        directAddrPtr_ =
+        (
+            new labelList(patch_.patch().patchSlice(mpm_.faceMap()))
+        );
 
         labelList& addr = *directAddrPtr_;
 
         // Shift to local patch indices.
         // Also, check mapping for hits into other patches / internal faces.
-        forAll (addr, faceI)
+        forAll(addr, faceI)
         {
             if
             (
@@ -211,22 +249,55 @@ void topoPatchMapper::calcAddressing() const
             }
             else
             {
+                // Relax addressing requirement for
+                // processor patch faces. These require
+                // cell-to-face interpolation anyway.
+                if (isA<processorPolyPatch>(patch_.patch()))
+                {
+                    // Artificially map from face[0] of this patch.
+                    addr[faceI] = 0;
+                    continue;
+                }
+
+                // Write out for post-processing
+                meshOps::writeVTK
+                (
+                    mpm_.mesh(),
+                    "patchFacePatchError_"
+                  + Foam::name(faceI),
+                    labelList(1, faceI),
+                    2,
+                    mpm_.mesh().points(),
+                    List<edge>(0),
+                    mpm_.mesh().faces()
+                );
+
                 FatalErrorIn
                 (
                     "void topoPatchMapper::calcAddressing() const"
                 )
                     << "Addressing into another patch is not allowed."
+                    << nl << " Patch: " << patch_.name()
+                    << nl << " Patch index: " << patch_.index()
                     << nl << " Patch face index: " << faceI
                     << nl << " addr[faceI]: " << addr[faceI]
                     << nl << " oldPatchStart: " << oldPatchStart
                     << nl << " oldPatchSize: " << oldPatchSize
                     << nl << " oldPatchEnd: " << oldPatchEnd
+                    << nl << " nInserted: " << insertedObjectLabels().size()
                     << abort(FatalError);
             }
         }
     }
     else
     {
+        if (oldPatchSize == 0)
+        {
+            // Nothing to map from. Return empty.
+            interpolationAddrPtr_ = new labelListList(0);
+            return;
+        }
+
         // Interpolative addressing
         interpolationAddrPtr_ = new labelListList(patchSize(), labelList(0));
         labelListList& addr = *interpolationAddrPtr_;
@@ -267,6 +338,8 @@ void topoPatchMapper::calcAddressing() const
                         "void topoPatchMapper::calcAddressing() const"
                     )
                         << "Addressing into another patch is not allowed."
+                        << nl << " Patch: " << patch_.name()
+                        << nl << " Patch index: " << patch_.index()
                         << nl << " Patch face index: " << faceI
                         << nl << " faceMap[faceI]: " << oldFace
                         << nl << " oldPatchStart: " << oldPatchStart
@@ -284,6 +357,17 @@ void topoPatchMapper::calcAddressing() const
         {
             if (addr[faceI].empty())
             {
+                // Relax addressing requirement for
+                // processor patch faces. These require
+                // cell-to-face interpolation anyway.
+                if (isA<processorPolyPatch>(patch_.patch()))
+                {
+                    // Artificially map from face[0] of this patch.
+                    addr[faceI] = labelList(1, 0);
+
+                    continue;
+                }
+
                 FatalErrorIn
                 (
                     "void topoPatchMapper::calcAddressing() const"
@@ -316,6 +400,13 @@ void topoPatchMapper::calcInverseDistanceWeights() const
     // Fetch interpolative addressing
     const labelListList& addr = addressing();
 
+    if (addr.empty())
+    {
+        // Nothing to map from. Return empty.
+        weightsPtr_ = new scalarListList(0);
+        return;
+    }
+
     // Allocate memory
     weightsPtr_ = new scalarListList(patchSize());
     scalarListList& w = *weightsPtr_;
@@ -386,12 +477,20 @@ void topoPatchMapper::calcIntersectionWeightsAndCentres() const
     // Fetch interpolative addressing
     const labelListList& addr = addressing();
 
-    // Allocate memory
-    areasPtr_ = new List<scalarField>(patchSize(), scalarField(0));
-    List<scalarField>& a = *areasPtr_;
+    if (addr.empty())
+    {
+        // Nothing to map from. Return empty.
+        areasPtr_ = new List<scalarList>(0);
+        centresPtr_ = new List<vectorList>(0);
+        return;
+    }
 
-    centresPtr_ = new List<vectorField>(patchSize(), vectorField(0));
-    List<vectorField>& x = *centresPtr_;
+    // Allocate memory
+    areasPtr_ = new List<scalarList>(patchSize(), scalarList(0));
+    List<scalarList>& a = *areasPtr_;
+
+    centresPtr_ = new List<vectorList>(patchSize(), vectorList(0));
+    List<vectorList>& x = *centresPtr_;
 
     // Obtain stored face-centres
     const vectorField& faceCentres = tMapper_.patchCentres(patch_.index());
@@ -418,8 +517,8 @@ void topoPatchMapper::calcIntersectionWeightsAndCentres() const
         // Check if this is indeed a mapped face
         if (mo.size() == 1 && x[faceI].empty() && a[faceI].empty())
         {
-            x[faceI] = vectorField(1, faceCentres[mo[0]]);
-            a[faceI] = scalarField(1, 1.0);
+            x[faceI] = vectorList(1, faceCentres[mo[0]]);
+            a[faceI] = scalarList(1, 1.0);
         }
     }
 
@@ -441,13 +540,13 @@ void topoPatchMapper::calcIntersectionWeightsAndCentres() const
 }
 
 
-const List<scalarField>& topoPatchMapper::intersectionWeights() const
+const List<scalarList>& topoPatchMapper::intersectionWeights() const
 {
     if (direct())
     {
         FatalErrorIn
         (
-            "const List<scalarField>& "
+            "const List<scalarList>& "
             "topoPatchMapper::intersectionWeights() const"
         )   << "Requested interpolative weights for a direct mapper."
             << abort(FatalError);
@@ -462,13 +561,13 @@ const List<scalarField>& topoPatchMapper::intersectionWeights() const
 }
 
 
-const List<vectorField>& topoPatchMapper::intersectionCentres() const
+const List<vectorList>& topoPatchMapper::intersectionCentres() const
 {
     if (direct())
     {
         FatalErrorIn
         (
-            "const List<vectorField>& "
+            "const List<vectorList>& "
             "topoPatchMapper::intersectionCentres() const"
         )   << "Requested interpolative weights for a direct mapper."
             << abort(FatalError);
@@ -497,6 +596,8 @@ topoPatchMapper::topoPatchMapper
     mpm_(mpm),
     tMapper_(mapper),
     direct_(false),
+    sizeBeforeMapping_(0),
+    conservative_(false),
     directAddrPtr_(NULL),
     interpolationAddrPtr_(NULL),
     weightsPtr_(NULL),
@@ -506,6 +607,39 @@ topoPatchMapper::topoPatchMapper
     areasPtr_(NULL),
     centresPtr_(NULL)
 {
+    // Compute sizeBeforeMapping.
+    // - This needs to be done before insertedObjects
+    //   is computed to determine direct mapping
+    if (isA<emptyPolyPatch>(patch_.patch()))
+    {
+        sizeBeforeMapping_ = 0;
+    }
+    else
+    {
+        label patchIndex = patch_.index();
+        label totalSize = mpm_.oldPatchSizes()[patchIndex];
+
+        // Fetch offset sizes from topoMapper
+        const labelListList& sizes = tMapper_.patchSizes();
+
+        // Add offset sizes
+        if (sizes.size())
+        {
+            // Fetch number of physical patches
+            label nPhysical = sizes[0].size();
+
+            if (patchIndex < nPhysical)
+            {
+                forAll(sizes, pI)
+                {
+                    totalSize += sizes[pI][patchIndex];
+                }
+            }
+        }
+
+        sizeBeforeMapping_ = totalSize;
+    }
+
     // Check for the possibility of direct mapping
     if (insertedObjects())
     {
@@ -543,12 +677,7 @@ label topoPatchMapper::size() const
 //- Return size before mapping
 label topoPatchMapper::sizeBeforeMapping() const
 {
-    if (patch_.type() == "empty")
-    {
-        return 0;
-    }
-
-    return mpm_.oldPatchSizes()[patch_.index()];
+    return sizeBeforeMapping_;
 }
 
 
@@ -616,6 +745,16 @@ const scalarListList& topoPatchMapper::weights() const
             << abort(FatalError);
     }
 
+    if (conservative_)
+    {
+        if (!areasPtr_ && !centresPtr_)
+        {
+            calcIntersectionWeightsAndCentres();
+        }
+
+        return *areasPtr_;
+    }
+
     if (!weightsPtr_)
     {
         calcInverseDistanceWeights();
@@ -668,96 +807,6 @@ const labelListList& topoPatchMapper::insertedFaceAddressing() const
 }
 
 
-//- Map the patch field
-template <class Type>
-void topoPatchMapper::mapPatchField
-(
-    const word& fieldName,
-    Field<Type>& pF
-) const
-{
-    // To invoke inverse-distance weighting, use this:
-    // pF.autoMap(*this);
-
-    // Check for possibility of direct mapping
-    if (direct())
-    {
-        pF.autoMap(*this);
-    }
-    else
-    {
-        if (pF.size() != sizeBeforeMapping())
-        {
-            FatalErrorIn
-            (
-                "\n\n"
-                "void topoCellMapper::mapPatchField<Type>\n"
-                "(\n"
-                "    const word& fieldName,\n"
-                "    Field<Type>& iF\n"
-                ") const\n"
-            )  << "Incompatible size before mapping." << nl
-               << " Field: " << fieldName << nl
-               << " Field size: " << pF.size() << nl
-               << " map size: " << sizeBeforeMapping() << nl
-               << abort(FatalError);
-        }
-
-        // Fetch addressing
-        const labelListList& pAddressing = addressing();
-        const List<scalarField>& wF = intersectionWeights();
-
-        // Compute the integral of the source field
-        Type intSource = sum(pF * tMapper_.patchAreas(patch_.index()));
-
-        // Copy the original field
-        Field<Type> fieldCpy(pF);
-
-        // Resize to current dimensions
-        pF.setSize(size());
-
-        // Map the patch field
-        forAll(pF, faceI)
-        {
-            const labelList& addr = pAddressing[faceI];
-
-            pF[faceI] = pTraits<Type>::zero;
-
-            // Accumulate area-weighted interpolate
-            forAll(addr, faceJ)
-            {
-                pF[faceI] +=
-                (
-                    wF[faceI][faceJ] * fieldCpy[addr[faceJ]]
-                );
-            }
-        }
-
-        // Compute the integral of the target field
-        const polyPatch& ppI = mpm_.mesh().boundaryMesh()[patch_.index()];
-
-        Type intTarget = sum(pF * mag(ppI.faceAreas()));
-
-        if (polyMesh::debug)
-        {
-            int oldP = Info().precision();
-
-            // Compare the global integral
-            Info << " Field : " << fieldName
-                 << " Patch : " << ppI.name()
-                 << " integral errors : "
-                 << setprecision(15)
-                 << " source : " << mag(intSource)
-                 << " target : " << mag(intTarget)
-                 << " norm : "
-                 << (mag(intTarget - intSource) / (mag(intSource) + VSMALL))
-                 << setprecision(oldP)
-                 << endl;
-        }
-    }
-}
-
-
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 void topoPatchMapper::operator=(const topoPatchMapper& rhs)
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
index c734d72c0..9fa29c5f3 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
@@ -43,17 +43,15 @@ SourceFiles
 #ifndef topoPatchMapper_H
 #define topoPatchMapper_H
 
-#include "morphFieldMapper.H"
+#include "vectorList.H"
+#include "topoMapper.H"
+#include "fvPatchFieldMapper.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-// Class forward declarations
-class topoMapper;
-class mapPolyMesh;
-
 /*---------------------------------------------------------------------------*\
                     Class topoPatchMapper Declaration
 \*---------------------------------------------------------------------------*/
@@ -76,6 +74,12 @@ class topoPatchMapper
         //- Is the mapping direct
         bool direct_;
 
+        //- Size before mapping
+        mutable label sizeBeforeMapping_;
+
+        //- Is the mapping conservative
+        mutable bool conservative_;
+
     // Demand-driven private data
 
         //- Direct addressing
@@ -97,10 +101,10 @@ class topoPatchMapper
         mutable labelListList* insertedFaceAddressingPtr_;
 
         //- Interpolation areas
-        mutable List<scalarField>* areasPtr_;
+        mutable List<scalarList>* areasPtr_;
 
         //- Interpolation centres
-        mutable List<vectorField>* centresPtr_;
+        mutable List<vectorList>* centresPtr_;
 
     // Private Member Functions
 
@@ -123,10 +127,10 @@ class topoPatchMapper
         void calcIntersectionWeightsAndCentres() const;
 
         //- Return intersection area weights
-        const List<scalarField>& intersectionWeights() const;
+        const List<scalarList>& intersectionWeights() const;
 
         //- Return intersection area centres
-        const List<vectorField>& intersectionCentres() const;
+        const List<vectorList>& intersectionCentres() const;
 
         //- Clear out local storage
         void clearOut();
@@ -196,8 +200,10 @@ public:
 
 } // End namespace Foam
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #ifdef NoRepository
-#include "topoPatchMapper.C"
+#   include "topoPatchMapperTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
new file mode 100644
index 000000000..741322fa2
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "mapPolyMesh.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Map the patch field
+template <class Type>
+void topoPatchMapper::mapPatchField
+(
+    const word& fieldName,
+    Field<Type>& pF
+) const
+{
+    // Specify that mapping is conservative
+    conservative_ = true;
+
+    // Map patchField onto itself
+    pF.autoMap(*this);
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C
index dfd507990..296ea9341 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C
@@ -33,7 +33,7 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 #include "topoMapper.H"
 #include "mapPolyMesh.H"
@@ -157,11 +157,24 @@ topoSurfaceMapper::topoSurfaceMapper
     mpm_(mpm),
     tMapper_(mapper),
     direct_(false),
+    sizeBeforeMapping_(mpm.nOldInternalFaces()),
     directAddrPtr_(NULL),
     interpolationAddrPtr_(NULL),
     weightsPtr_(NULL),
     insertedFaceLabelsPtr_(NULL)
 {
+    // Fetch offset sizes from topoMapper
+    const labelList& sizes = tMapper_.faceSizes();
+
+    // Add offset sizes
+    if (sizes.size())
+    {
+        forAll(sizes, pI)
+        {
+            sizeBeforeMapping_ += sizes[pI];
+        }
+    }
+
     // Calculate the insertedFaces list
     calcInsertedFaceLabels();
 
@@ -188,7 +201,7 @@ label topoSurfaceMapper::size() const
 //- Return size before mapping
 label topoSurfaceMapper::sizeBeforeMapping() const
 {
-    return mpm_.nOldInternalFaces();
+    return sizeBeforeMapping_;
 }
 
 
@@ -291,61 +304,6 @@ const labelHashSet& topoSurfaceMapper::flipFaceFlux() const
 }
 
 
-//- Map the internal field
-template <class Type>
-void topoSurfaceMapper::mapInternalField
-(
-    const word& fieldName,
-    Field<Type>& iF
-) const
-{
-    if (iF.size() != sizeBeforeMapping())
-    {
-        FatalErrorIn
-        (
-            "\n\n"
-            "void topoSurfaceMapper::mapInternalField<Type>\n"
-            "(\n"
-            "    Field<Type>& iF\n"
-            ") const\n"
-        )  << "Incompatible size before mapping." << nl
-           << " Field: " << fieldName << nl
-           << " Field size: " << iF.size() << nl
-           << " map size: " << sizeBeforeMapping() << nl
-           << abort(FatalError);
-    }
-
-    // Map the internal field
-    iF.autoMap(*this);
-
-    // Flip the flux
-    const labelList flipFaces = flipFaceFlux().toc();
-
-    forAll (flipFaces, i)
-    {
-        if (flipFaces[i] < iF.size())
-        {
-            iF[flipFaces[i]] *= -1.0;
-        }
-        else
-        {
-            FatalErrorIn
-            (
-                "\n\n"
-                "void topoSurfaceMapper::mapInternalField<Type>\n"
-                "(\n"
-                "    Field<Type>& iF\n"
-                ") const\n"
-            )  << "Cannot flip boundary face fluxes." << nl
-               << " Field: " << fieldName << nl
-               << " Field size: " << iF.size() << nl
-               << " Face flip index: " << flipFaces[i] << nl
-               << abort(FatalError);
-        }
-    }
-}
-
-
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
 void topoSurfaceMapper::operator=(const topoSurfaceMapper& rhs)
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H
index 548f8fdae..e37b87666 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H
@@ -43,6 +43,7 @@ SourceFiles
 #ifndef topoSurfaceMapper_H
 #define topoSurfaceMapper_H
 
+#include "topoMapper.H"
 #include "morphFieldMapper.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -50,10 +51,6 @@ SourceFiles
 namespace Foam
 {
 
-// Class forward declarations
-class topoMapper;
-class mapPolyMesh;
-
 /*---------------------------------------------------------------------------*\
                         Class topoSurfaceMapper Declaration
 \*---------------------------------------------------------------------------*/
@@ -76,6 +73,9 @@ class topoSurfaceMapper
         //- Is the mapping direct
         bool direct_;
 
+        //- Size before mapping
+        mutable label sizeBeforeMapping_;
+
     // Demand-driven private data
 
         //- Direct addressing
@@ -165,8 +165,10 @@ public:
 
 } // End namespace Foam
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #ifdef NoRepository
-#include "topoSurfaceMapper.C"
+#   include "topoSurfaceMapperTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapperTemplates.C
new file mode 100644
index 000000000..710ef044b
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapperTemplates.C
@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Map the internal field
+template <class Type>
+void topoSurfaceMapper::mapInternalField
+(
+    const word& fieldName,
+    Field<Type>& iF
+) const
+{
+    if (iF.size() != sizeBeforeMapping())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "void topoSurfaceMapper::mapInternalField<Type>\n"
+            "(\n"
+            "    Field<Type>& iF\n"
+            ") const\n"
+        )  << "Incompatible size before mapping." << nl
+           << " Field: " << fieldName << nl
+           << " Field size: " << iF.size() << nl
+           << " map size: " << sizeBeforeMapping() << nl
+           << abort(FatalError);
+    }
+
+    // Map the internal field
+    iF.autoMap(*this);
+
+    // Flip the flux
+    const labelList flipFaces = flipFaceFlux().toc();
+
+    forAll (flipFaces, i)
+    {
+        if (flipFaces[i] < iF.size())
+        {
+            iF[flipFaces[i]] *= -1.0;
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "\n\n"
+                "void topoSurfaceMapper::mapInternalField<Type>\n"
+                "(\n"
+                "    Field<Type>& iF\n"
+                ") const\n"
+            )  << "Cannot flip boundary face fluxes." << nl
+               << " Field: " << fieldName << nl
+               << " Field size: " << iF.size() << nl
+               << " Face flip index: " << flipFaces[i] << nl
+               << abort(FatalError);
+        }
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
index 8a3a0b11a..2b6688c4b 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
@@ -33,7 +33,7 @@ Author
     University of Massachusetts Amherst
     All rights reserved
 
-\*----------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 #include "Time.H"
 #include "meshOps.H"
@@ -41,8 +41,8 @@ Author
 #include "Pstream.H"
 #include "triFace.H"
 #include "IOmanip.H"
-#include "HashSet.H"
 #include "polyMesh.H"
+#include "OFstream.H"
 #include "triPointRef.H"
 #include "tetPointRef.H"
 
@@ -56,7 +56,7 @@ namespace meshOps
 
 // Utility method to build a hull of cells
 // connected to the edge (for 2D simplical meshes)
-void constructPrismHull
+inline void constructPrismHull
 (
     const label eIndex,
     const UList<face>& faces,
@@ -126,7 +126,7 @@ void constructPrismHull
 
 // Utility method to build a hull of cells (and faces)
 // around an edge (for 3D simplical meshes)
-void constructHull
+inline void constructHull
 (
     const label eIndex,
     const UList<face>& faces,
@@ -136,7 +136,7 @@ void constructHull
     const UList<label>& neighbour,
     const UList<labelList>& faceEdges,
     const UList<labelList>& edgeFaces,
-    const UList<labelList>& edgePoints,
+    const labelList& vertexHull,
     labelList& hullEdges,
     labelList& hullFaces,
     labelList& hullCells,
@@ -145,9 +145,9 @@ void constructHull
 {
     // [1] hullEdges is an ordered list of edge-labels around eIndex,
     //     but not connected to it.
-    //      - Ordering is in the same manner as edgePoints.
+    //      - Ordering is in the same manner as vertexHull.
     // [2] hullFaces is an ordered list of face-labels connected to eIndex.
-    //      - Ordering is in the same manner as edgePoints.
+    //      - Ordering is in the same manner as vertexHull.
     // [3] hullCells is an ordered list of cell-labels connected to eIndex.
     //      - For boundary hulls, the last cell label is -1
     // [4] ringEntities are edges and faces connected to eIndex[0] and eIndex[1]
@@ -162,7 +162,6 @@ void constructHull
     // Obtain a reference to this edge, and its edgeFaces
     const edge& edgeToCheck = edges[eIndex];
     const labelList& eFaces = edgeFaces[eIndex];
-    const labelList& hullVertices = edgePoints[eIndex];
 
     // Loop through all faces of this edge and add them to hullFaces
     forAll(eFaces, faceI)
@@ -170,7 +169,7 @@ void constructHull
         const face& faceToCheck = faces[eFaces[faceI]];
 
         // Find the isolated point on this face,
-        // and compare it with hullVertices
+        // and compare it with vertexHull
         meshOps::findIsolatedPoint
         (
             faceToCheck,
@@ -181,9 +180,9 @@ void constructHull
 
         found = false;
 
-        forAll(hullVertices, indexI)
+        forAll(vertexHull, indexI)
         {
-            if (hullVertices[indexI] == otherPoint)
+            if (vertexHull[indexI] == otherPoint)
             {
                 // Fill in the position of this face on the hull
                 hullFaces[indexI] = eFaces[faceI];
@@ -235,8 +234,8 @@ void constructHull
 
                 if (hullCells[indexI] != -1)
                 {
-                    label nextI = hullVertices.fcIndex(indexI);
-                    label nextHullPoint = hullVertices[nextI];
+                    label nextI = vertexHull.fcIndex(indexI);
+                    label nextHullPoint = vertexHull[nextI];
                     const cell& currCell = cells[hullCells[indexI]];
 
                     // Look for the ring-faces
@@ -316,7 +315,7 @@ void constructHull
                 << " edgeFaces connectivity is inconsistent. " << nl
                 << " Edge: " << eIndex << ":: " << edgeToCheck << nl
                 << " edgeFaces: " << eFaces << nl
-                << " edgePoints: " << hullVertices
+                << " vertexHull: " << vertexHull
                 << abort(FatalError);
         }
     }
@@ -334,7 +333,7 @@ void constructHull
 //    Renaud Waldura
 //    Dijkstra's Shortest Path Algorithm in Java
 //    http://renaud.waldura.com/
-bool Dijkstra
+inline bool Dijkstra
 (
     const Map<point>& points,
     const Map<edge>& edges,
@@ -464,13 +463,47 @@ bool Dijkstra
         }
     }
 
+    /*
+    // Write out the path
+    if (debug > 3)
+    {
+        if (foundEndPoint)
+        {
+            DynamicList<label> pathNodes(50);
+
+            label currentPoint = endPoint;
+
+            while (currentPoint != startPoint)
+            {
+                pathNodes.append(currentPoint);
+
+                currentPoint = pi[currentPoint];
+            }
+
+            pathNodes.append(startPoint);
+
+            pathNodes.shrink();
+
+            writeVTK
+            (
+                "DijkstraPath_"
+              + Foam::name(startPoint)
+              + '_'
+              + Foam::name(endPoint),
+                pathNodes,
+                0
+            );
+        }
+    }
+    */
+
     return foundEndPoint;
 }
 
 
 // Select a list of elements from connectivity,
 // and output to a VTK format
-void writeVTK
+inline void writeVTK
 (
     const polyMesh& mesh,
     const word& name,
@@ -480,7 +513,10 @@ void writeVTK
     const UList<edge>& edges,
     const UList<face>& faces,
     const UList<cell>& cells,
-    const UList<label>& owner
+    const UList<label>& owner,
+    const UList<scalar>& scalField,
+    const UList<label>& lablField,
+    const UList<vector>& vectField
 )
 {
     label nTotalCells = 0;
@@ -502,236 +538,320 @@ void writeVTK
             continue;
         }
 
-        // Are we looking at points?
-        if (primitiveType == 0)
+        bool isPolyhedron = false;
+
+        switch (primitiveType)
         {
-            // Size the list
-            cpList[nCells].setSize(1);
-
-            cpList[nCells] = cList[cellI];
-
-            nTotalCells++;
-        }
-
-        // Are we looking at edges?
-        if (primitiveType == 1)
-        {
-            // Size the list
-            cpList[nCells].setSize(2);
-
-            const edge& tEdge = edges[cList[cellI]];
-
-            cpList[nCells][0] = tEdge[0];
-            cpList[nCells][1] = tEdge[1];
-
-            nTotalCells += 2;
-        }
-
-        // Are we looking at faces?
-        if (primitiveType == 2)
-        {
-            const face& tFace = faces[cList[cellI]];
-
-            if (tFace.size() == 3)
+            // Are we looking at points?
+            case 0:
             {
                 // Size the list
-                cpList[nCells].setSize(3);
+                cpList[nCells].setSize(1);
 
-                // Write out in order
-                cpList[nCells][0] = tFace[0];
-                cpList[nCells][1] = tFace[1];
-                cpList[nCells][2] = tFace[2];
+                cpList[nCells] = cList[cellI];
 
-                nTotalCells += 3;
+                nTotalCells++;
+
+                break;
             }
-            else
-            if (tFace.size() == 4)
+
+            // Are we looking at edges?
+            case 1:
             {
                 // Size the list
-                cpList[nCells].setSize(4);
+                cpList[nCells].setSize(2);
 
-                // Write out in order
-                cpList[nCells][0] = tFace[0];
-                cpList[nCells][1] = tFace[1];
-                cpList[nCells][2] = tFace[2];
-                cpList[nCells][3] = tFace[3];
+                const edge& tEdge = edges[cList[cellI]];
 
-                nTotalCells += 4;
+                cpList[nCells][0] = tEdge[0];
+                cpList[nCells][1] = tEdge[1];
+
+                nTotalCells += 2;
+
+                break;
             }
-        }
 
-        // Are we looking at cells?
-        if (primitiveType == 3)
-        {
-            const cell& tCell = cells[cList[cellI]];
-
-            if (tCell.size() == 4)
+            // Are we looking at faces?
+            case 2:
             {
-                // Point-ordering for tetrahedra
-                const face& baseFace = faces[tCell[0]];
-                const face& checkFace = faces[tCell[1]];
+                const face& tFace = faces[cList[cellI]];
 
-                // Size the list
-                cpList[nCells].setSize(4);
+                // Size the list and assign
+                cpList[nCells] = tFace;
 
-                // Get the fourth point
-                label apexPoint =
-                (
-                    meshOps::findIsolatedPoint(baseFace, checkFace)
-                );
+                nTotalCells += tFace.size();
 
-                // Something's wrong with connectivity.
-                if (apexPoint == -1)
-                {
-                    FatalErrorIn
-                    (
-                        "void writeVTK\n"
-                        "(\n"
-                        "    const polyMesh& mesh,\n"
-                        "    const word& name,\n"
-                        "    const labelList& cList,\n"
-                        "    const label primitiveType,\n"
-                        "    const UList<point>& points,\n"
-                        "    const UList<edge>& edges,\n"
-                        "    const UList<face>& faces,\n"
-                        "    const UList<cell>& cells,\n"
-                        "    const UList<label>& owner\n"
-                        ") const\n"
-                    )
-                        << "Cell: " << cList[cellI]
-                        << ":: " << tCell
-                        << " has inconsistent connectivity."
-                        << abort(FatalError);
-                }
-
-                // Write-out in order
-                label ownCell = owner[tCell[0]];
-
-                if (ownCell == cList[cellI])
-                {
-                    cpList[nCells][0] = baseFace[2];
-                    cpList[nCells][1] = baseFace[1];
-                    cpList[nCells][2] = baseFace[0];
-                    cpList[nCells][3] = apexPoint;
-                }
-                else
-                {
-                    cpList[nCells][0] = baseFace[0];
-                    cpList[nCells][1] = baseFace[1];
-                    cpList[nCells][2] = baseFace[2];
-                    cpList[nCells][3] = apexPoint;
-                }
-
-                nTotalCells += 4;
+                break;
             }
-            else
-            if (tCell.size() == 5)
+
+            // Are we looking at cells?
+            case 3:
             {
-                // Point-ordering for wedge cells
-                label firstTriFace = -1;
+                const cell& tCell = cells[cList[cellI]];
 
-                // Size the list
-                cpList[nCells].setSize(6);
-
-                // Figure out triangle faces
-                forAll(tCell, faceI)
+                // Is face information provided?
+                if (faces.size())
                 {
-                    const face& cFace = faces[tCell[faceI]];
-
-                    if (cFace.size() == 3)
+                    if (tCell.size() == 4)
                     {
-                        if (firstTriFace == -1)
-                        {
-                            firstTriFace = tCell[faceI];
+                        // Point-ordering for tetrahedra
+                        const face& baseFace = faces[tCell[0]];
+                        const face& checkFace = faces[tCell[1]];
 
-                            // Right-handedness is assumed here.
-                            // Tri-faces are always on the boundary.
-                            cpList[nCells][0] = cFace[0];
-                            cpList[nCells][1] = cFace[1];
-                            cpList[nCells][2] = cFace[2];
+                        // Size the list
+                        cpList[nCells].setSize(4);
+
+                        // Get the fourth point
+                        label apexPoint =
+                        (
+                            meshOps::findIsolatedPoint(baseFace, checkFace)
+                        );
+
+                        // Something's wrong with connectivity.
+                        if (apexPoint == -1)
+                        {
+                            FatalErrorIn
+                            (
+                                "void meshOps::writeVTK\n"
+                                "(\n"
+                                "    const polyMesh& mesh,\n"
+                                "    const word& name,\n"
+                                "    const labelList& cList,\n"
+                                "    const label primitiveType,\n"
+                                "    const UList<point>& meshPoints,\n"
+                                "    const UList<edge>& edges,\n"
+                                "    const UList<face>& faces,\n"
+                                "    const UList<cell>& cells,\n"
+                                "    const UList<label>& owner\n"
+                                "    const UList<scalar>& scalField,\n"
+                                "    const UList<label>& lablField,\n"
+                                "    const UList<vector>& vectField\n"
+                                ")\n"
+                            )
+                                << "Cell: " << cList[cellI]
+                                << ":: " << tCell
+                                << " has inconsistent connectivity."
+                                << abort(FatalError);
+                        }
+
+                        // Write-out in order
+                        label ownCell = owner[tCell[0]];
+
+                        if (ownCell == cList[cellI])
+                        {
+                            cpList[nCells][0] = baseFace[2];
+                            cpList[nCells][1] = baseFace[1];
+                            cpList[nCells][2] = baseFace[0];
+                            cpList[nCells][3] = apexPoint;
                         }
                         else
                         {
-                            // Detect the three other points.
-                            forAll(tCell, faceJ)
+                            cpList[nCells][0] = baseFace[0];
+                            cpList[nCells][1] = baseFace[1];
+                            cpList[nCells][2] = baseFace[2];
+                            cpList[nCells][3] = apexPoint;
+                        }
+
+                        nTotalCells += 4;
+                    }
+                    else
+                    if (tCell.size() > 4)
+                    {
+                        // Point ordering for polyhedra
+                        isPolyhedron = true;
+
+                        // First obtain the face count
+                        label npF = 0;
+
+                        forAll(tCell, faceI)
+                        {
+                            npF += faces[tCell[faceI]].size();
+                        }
+
+                        // Size the list
+                        cpList[nCells].setSize(tCell.size() + npF + 1);
+
+                        // Fill in facePoints
+                        label nP = 0;
+
+                        // Fill in the number of faces
+                        cpList[nCells][nP++] = tCell.size();
+
+                        forAll(tCell, faceI)
+                        {
+                            const face& checkFace = faces[tCell[faceI]];
+
+                            if (checkFace.empty())
                             {
-                                const face& nFace = faces[tCell[faceJ]];
-
-                                if (nFace.size() == 4)
-                                {
-                                    // Search for vertices on cFace
-                                    // in this face.
-                                    forAll(cFace, I)
-                                    {
-                                        label i = nFace.which(cFace[I]);
-
-                                        if (i != -1)
-                                        {
-                                            label p = nFace.prevLabel(i);
-                                            label n = nFace.nextLabel(i);
-
-                                            if (p == cpList[nCells][0])
-                                            {
-                                                cpList[nCells][3] = cFace[I];
-                                            }
-
-                                            if (p == cpList[nCells][1])
-                                            {
-                                                cpList[nCells][4] = cFace[I];
-                                            }
-
-                                            if (p == cpList[nCells][2])
-                                            {
-                                                cpList[nCells][5] = cFace[I];
-                                            }
-
-                                            if (n == cpList[nCells][0])
-                                            {
-                                                cpList[nCells][3] = cFace[I];
-                                            }
-
-                                            if (n == cpList[nCells][1])
-                                            {
-                                                cpList[nCells][4] = cFace[I];
-                                            }
-
-                                            if (n == cpList[nCells][2])
-                                            {
-                                                cpList[nCells][5] = cFace[I];
-                                            }
-                                        }
-                                    }
-                                }
+                                FatalErrorIn("void meshOps::writeVTK()")
+                                    << " Empty face: " << tCell[faceI]
+                                    << abort(FatalError);
                             }
 
-                            break;
+                            // First fill in face size
+                            cpList[nCells][nP++] = checkFace.size();
+
+                            // Next fill in points in order
+                            if (owner[tCell[faceI]] == cList[cellI])
+                            {
+                                forAll(checkFace, pI)
+                                {
+                                    cpList[nCells][nP++] = checkFace[pI];
+                                }
+                            }
+                            else
+                            {
+                                forAllReverse(checkFace, pI)
+                                {
+                                    cpList[nCells][nP++] = checkFace[pI];
+                                }
+                            }
                         }
+
+                        nTotalCells += (tCell.size() + npF + 1);
+                    }
+                    else
+                    {
+                        FatalErrorIn("void meshOps::writeVTK()")
+                            << " Wrong cell size: " << tCell << nl
+                            << " Index: " << cList[cellI] << nl
+                            << abort(FatalError);
+                    }
+                }
+                else
+                {
+                    // No face information.
+                    // Assume cell-to-node information.
+                    if (tCell.size() == 4)
+                    {
+                        // Build a face out of first three points.
+                        triPointRef tpr
+                        (
+                            meshPoints[tCell[0]],
+                            meshPoints[tCell[1]],
+                            meshPoints[tCell[2]]
+                        );
+
+                        // Fetch fourth point
+                        const point& d = meshPoints[tCell[3]];
+
+                        scalar dDotN = ((d - tpr.a()) & tpr.normal());
+
+                        // Size the list
+                        cpList[nCells].setSize(4);
+
+                        if (dDotN > 0.0)
+                        {
+                            // Correct orientation
+                            cpList[nCells][0] = tCell[0];
+                            cpList[nCells][1] = tCell[1];
+                            cpList[nCells][2] = tCell[2];
+                            cpList[nCells][3] = tCell[3];
+                        }
+                        else
+                        {
+                            // Flip triangle
+                            cpList[nCells][0] = tCell[2];
+                            cpList[nCells][1] = tCell[1];
+                            cpList[nCells][2] = tCell[0];
+                            cpList[nCells][3] = tCell[3];
+                        }
+
+                        nTotalCells += 4;
+                    }
+                    else
+                    {
+                        FatalErrorIn("void meshOps::writeVTK()")
+                            << " Wrong cell size: " << tCell << nl
+                            << " Index: " << cList[cellI] << nl
+                            << abort(FatalError);
                     }
                 }
 
-                nTotalCells += 6;
+                break;
+            }
+
+            default:
+            {
+                FatalErrorIn("void meshOps::writeVTK() const")
+                    << " Incorrect primitiveType: "
+                    << primitiveType
+                    << abort(FatalError);
             }
         }
 
         // Renumber to local ordering
-        forAll(cpList[nCells], pointI)
+        if (isPolyhedron)
         {
-            // Check if this point was added to the map
-            if (!pointMap.found(cpList[nCells][pointI]))
+            // Polyhedra also contain face sizes, so use a different scheme
+            label pCtr = 0;
+
+            // Fetch number of faces
+            label npF = cpList[nCells][pCtr++];
+
+            for (label i = 0; i < npF; i++)
             {
-                // Point was not found, so add it
-                points[nPoints] = meshPoints[cpList[nCells][pointI]];
+                // Fetch number of points
+                label npP = cpList[nCells][pCtr++];
 
-                // Update the map
-                pointMap.insert(cpList[nCells][pointI], nPoints);
-                reversePointMap.insert(nPoints, cpList[nCells][pointI]);
+                // Read points in order
+                for (label j = 0; j < npP; j++)
+                {
+                    // Check if this point was added to the map
+                    if (!pointMap.found(cpList[nCells][pCtr]))
+                    {
+                        // Resize pointField if necessary
+                        if (nPoints >= points.size())
+                        {
+                            points.setSize(2 * nPoints);
+                        }
 
-                // Increment the number of points
-                nPoints++;
+                        // Point was not found, so add it
+                        points[nPoints] = meshPoints[cpList[nCells][pCtr]];
+
+                        // Update the map
+                        pointMap.insert(cpList[nCells][pCtr], nPoints);
+                        reversePointMap.insert(nPoints, cpList[nCells][pCtr]);
+
+                        // Increment the number of points
+                        nPoints++;
+                    }
+
+                    // Renumber it.
+                    cpList[nCells][pCtr] = pointMap[cpList[nCells][pCtr]];
+
+                    // Increment point counter
+                    pCtr++;
+                }
             }
+        }
+        else
+        {
+            forAll(cpList[nCells], pointI)
+            {
+                // Check if this point was added to the map
+                if (!pointMap.found(cpList[nCells][pointI]))
+                {
+                    // Resize pointField if necessary
+                    if (nPoints >= points.size())
+                    {
+                        points.setSize(2 * nPoints);
+                    }
 
-            // Renumber it.
-            cpList[nCells][pointI] = pointMap[cpList[nCells][pointI]];
+                    // Point was not found, so add it
+                    points[nPoints] = meshPoints[cpList[nCells][pointI]];
+
+                    // Update the map
+                    pointMap.insert(cpList[nCells][pointI], nPoints);
+                    reversePointMap.insert(nPoints, cpList[nCells][pointI]);
+
+                    // Increment the number of points
+                    nPoints++;
+                }
+
+                // Renumber it.
+                cpList[nCells][pointI] = pointMap[cpList[nCells][pointI]];
+            }
         }
 
         // Update the cell map.
@@ -752,13 +872,16 @@ void writeVTK
         cpList,
         primitiveType,
         reversePointMap,
-        reverseCellMap
+        reverseCellMap,
+        scalField,
+        lablField,
+        vectField
     );
 }
 
 
 // Actual routine to write out the VTK file
-void writeVTK
+inline void writeVTK
 (
     const polyMesh& mesh,
     const word& name,
@@ -769,7 +892,10 @@ void writeVTK
     const labelListList& cpList,
     const label primitiveType,
     const Map<label>& reversePointMap,
-    const Map<label>& reverseCellMap
+    const Map<label>& reverseCellMap,
+    const UList<scalar>& scalField,
+    const UList<label>& lablField,
+    const UList<vector>& vectField
 )
 {
     // Make the directory
@@ -830,48 +956,54 @@ void writeVTK
     {
         forAll(cpList, i)
         {
-            if (cpList[i].size() == 1)
+            switch (primitiveType)
             {
                 // Vertex
-                file << "1" << nl;
-            }
+                case 0:
+                {
+                    file << "1" << nl;
+                    break;
+                }
 
-            if (cpList[i].size() == 2)
-            {
                 // Edge
-                file << "3" << nl;
-            }
+                case 1:
+                {
+                    file << "3" << nl;
+                    break;
+                }
 
-            if (cpList[i].size() == 3)
-            {
-                // Triangle face
-                file << "5" << nl;
-            }
+                // General Polygonal Face
+                case 2:
+                {
+                    file << "7" << nl;
+                    break;
+                }
 
-            if
-            (
-                (cpList[i].size() == 4) &&
-                (primitiveType == 2)
-            )
-            {
-                // Quad face
-                file << "9" << nl;
-            }
+                // Cell
+                case 3:
+                {
+                    if (cpList[i].size() == 4)
+                    {
+                        // Tetrahedron
+                        file << "10" << nl;
+                    }
+                    else
+                    if (cpList[i].size() > 4)
+                    {
+                        // Polyhedron
+                        file << "42" << nl;
+                    }
 
-            if
-            (
-                (cpList[i].size() == 4) &&
-                (primitiveType == 3)
-            )
-            {
-                // Tetrahedron
-                file << "10" << nl;
-            }
+                    break;
+                }
 
-            if (cpList[i].size() == 6)
-            {
-                // Wedge
-                file << "13" << nl;
+                default:
+                {
+                    FatalErrorIn("void meshOps::writeVTK() const")
+                        << " Incorrect primitiveType: "
+                        << primitiveType
+                        << abort(FatalError);
+                }
             }
         }
     }
@@ -885,44 +1017,169 @@ void writeVTK
         }
     }
 
-    // Write out indices for visualization.
+    label nCellFields = 0, nPointFields = 0;
+
     if (reverseCellMap.size())
     {
-        file << "CELL_DATA " << nCells << endl;
+        nCellFields++;
+    }
 
-        file << "FIELD CellFields 1" << endl;
+    if (scalField.size() == nCells && scalField.size())
+    {
+        nCellFields++;
+    }
 
-        file << "CellIds 1 " << nCells << " int" << endl;
+    if (lablField.size() == nCells && lablField.size())
+    {
+        nCellFields++;
+    }
 
-        for (label i = 0; i < nCells; i++)
-        {
-            file << reverseCellMap[i] << ' ';
-        }
-
-        file << endl;
+    if (vectField.size() == nCells && vectField.size())
+    {
+        nCellFields++;
     }
 
     // Write out indices for visualization.
+    if (nCellFields)
+    {
+        file << "CELL_DATA " << nCells << endl;
+
+        file << "FIELD CellFields " << nCellFields << endl;
+
+        if (reverseCellMap.size())
+        {
+            file << "CellIds 1 " << nCells << " int" << endl;
+
+            for (label i = 0; i < nCells; i++)
+            {
+                file << reverseCellMap[i] << ' ';
+            }
+
+            file << endl;
+        }
+
+        if (scalField.size() == nCells)
+        {
+            file << "CellScalars 1 " << nCells << " double" << endl;
+
+            forAll(scalField, i)
+            {
+                file << scalField[i] << ' ';
+            }
+
+            file << endl;
+        }
+
+        if (lablField.size() == nCells)
+        {
+            file << "CellLabels 1 " << nCells << " int" << endl;
+
+            forAll(lablField, i)
+            {
+                file << lablField[i] << ' ';
+            }
+
+            file << endl;
+        }
+
+        if (vectField.size() == nCells)
+        {
+            file << "CellVectors 3 " << nCells << " double" << endl;
+
+            forAll(vectField, i)
+            {
+                file << vectField[i].x() << ' '
+                     << vectField[i].y() << ' '
+                     << vectField[i].z() << ' ';
+            }
+
+            file << endl;
+        }
+    }
+
     if (reversePointMap.size())
+    {
+        nPointFields++;
+    }
+
+    if (scalField.size() == nPoints && scalField.size())
+    {
+        nPointFields++;
+    }
+
+    if (lablField.size() == nPoints && lablField.size())
+    {
+        nPointFields++;
+    }
+
+    if (vectField.size() == nPoints && vectField.size())
+    {
+        nPointFields++;
+    }
+
+    // Write out indices for visualization.
+    if (nPointFields)
     {
         file << "POINT_DATA " << nPoints << endl;
 
-        file << "FIELD PointFields 1" << endl;
+        file << "FIELD PointFields " << nPointFields << endl;
 
-        file << "PointIds 1 " << nPoints << " int" << endl;
-
-        for (label i = 0; i < nPoints; i++)
+        if (reversePointMap.size())
         {
-            file << reversePointMap[i] << ' ';
+            file << "PointIds 1 " << nPoints << " int" << endl;
+
+            for (label i = 0; i < nPoints; i++)
+            {
+                file << reversePointMap[i] << ' ';
+            }
+
+            file << endl;
         }
 
-        file << endl;
+        if (scalField.size() == nPoints)
+        {
+            file << "PointScalars 1 " << nPoints << " double" << endl;
+
+            forAll(scalField, i)
+            {
+                file << scalField[i] << ' ';
+            }
+
+            file << endl;
+        }
+
+        if (lablField.size() == nPoints)
+        {
+            file << "PointLabels 1 " << nPoints << " int" << endl;
+
+            forAll(lablField, i)
+            {
+                file << lablField[i] << ' ';
+            }
+
+            file << endl;
+        }
+
+        if (vectField.size() == nPoints)
+        {
+            file << "PointVectors 3 " << nPoints << " double" << endl;
+
+            forAll(vectField, i)
+            {
+                file << vectField[i].x() << ' '
+                     << vectField[i].y() << ' '
+                     << vectField[i].z() << ' ';
+            }
+
+            file << endl;
+        }
     }
 }
 
 
 } // End namespace meshOps
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
index a32f17c89..db3d78e41 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
@@ -43,7 +43,6 @@ SourceFiles
 #define meshOps_H
 
 #include "Map.H"
-#include "line.H"
 #include "point.H"
 #include "label.H"
 #include "scalar.H"
@@ -51,8 +50,10 @@ SourceFiles
 #include "cellList.H"
 #include "edgeList.H"
 #include "faceList.H"
-#include "triangle.H"
+#include "triPointRef.H"
+#include "tetPointRef.H"
 #include "vectorField.H"
+#include "linePointRef.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -93,7 +94,7 @@ namespace meshOps
 
     // Utility method to build a hull of cells
     // connected to the edge (for 2D simplical meshes)
-    void constructPrismHull
+    inline void constructPrismHull
     (
         const label eIndex,
         const UList<face>& faces,
@@ -107,7 +108,7 @@ namespace meshOps
 
     // Utility method to build a hull of cells (and faces)
     // around an edge (for 3D simplical meshes)
-    void constructHull
+    inline void constructHull
     (
         const label eIndex,
         const UList<face>& faces,
@@ -117,7 +118,7 @@ namespace meshOps
         const UList<label>& neighbour,
         const UList<labelList>& faceEdges,
         const UList<labelList>& edgeFaces,
-        const UList<labelList>& edgePoints,
+        const labelList& hullVertices,
         labelList& hullEdges,
         labelList& hullFaces,
         labelList& hullCells,
@@ -147,12 +148,12 @@ namespace meshOps
     (
         const label cIndex,
         const label fIndex,
-        const UList<face> faces,
-        const UList<cell> cells
+        const UList<face>& faces,
+        const UList<cell>& cells
     );
 
     // Given a cell index, find the centroid / volume of a cell.
-    inline bool cellCentreAndVolume
+    inline void cellCentreAndVolume
     (
         const label cIndex,
         const vectorField& points,
@@ -160,33 +161,28 @@ namespace meshOps
         const UList<cell>& cells,
         const UList<label>& owner,
         vector& centre,
-        scalar& volume,
-        bool checkClosed = false
+        scalar& volume
     );
 
     // Determine whether a segment intersects a triangular face
-    template <class T>
     inline bool segmentTriFaceIntersection
     (
-        const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
-        const line<Vector<T>, const Vector<T>&>& edgeToCheck,
-        const T& matchTol,
-        Vector<T>& intPoint
+        const triPointRef& faceToCheck,
+        const linePointRef& edgeToCheck,
+        vector& intPoint
     );
 
     // Determine whether the particular point lies
     // inside the given triangular face
-    template <class T>
     inline bool pointInTriFace
     (
-        const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
-        const Vector<T>& checkPoint,
-        const T& matchTol,
+        const triPointRef& faceToCheck,
+        const vector& checkPoint,
         bool testCoplanarity
     );
 
     // Dijkstra's algorithm for the shortest path problem
-    bool Dijkstra
+    inline bool Dijkstra
     (
         const Map<point>& points,
         const Map<edge>& edges,
@@ -195,17 +191,6 @@ namespace meshOps
         Map<label>& pi
     );
 
-    // Method to insert labels in a face, so that
-    // right-handedness is preserved.
-    template <class T>
-    inline void insertPointLabels
-    (
-        const Vector<T>& refNorm,
-        const Field<Vector<T> >& points,
-        const labelHashSet& pLabels,
-        face& modFace
-    );
-
     // Method to insert a label between two labels in a list
     inline void insertLabel
     (
@@ -247,23 +232,75 @@ namespace meshOps
         List<Type>& list
     );
 
+    // Parallel send
+    inline void pWrite
+    (
+        const label toID,
+        const label& data
+    );
+
+    // Parallel send (for fixed lists)
+    template <class Type, unsigned Size>
+    inline void pWrite
+    (
+        const label toID,
+        const FixedList<Type,Size>& data
+    );
+
+    // Parallel send (for lists)
+    template <class Type>
+    inline void pWrite
+    (
+        const label toID,
+        const UList<Type>& data
+    );
+
+    // Parallel receive
+    inline void pRead
+    (
+        const label fromID,
+        label& data
+    );
+
+    // Parallel receive (for fixed lists)
+    template <class Type, unsigned Size>
+    inline void pRead
+    (
+        const label fromID,
+        FixedList<Type,Size>& data
+    );
+
+    // Parallel receive (for lists)
+    template <class Type>
+    inline void pRead
+    (
+        const label fromID,
+        UList<Type>& data
+    );
+
+    // Wait for buffer transfer completion.
+    inline void waitForBuffers();
+
     // Select a list of elements from connectivity,
     // and output to a VTK format
-    void writeVTK
+    inline void writeVTK
     (
         const polyMesh& mesh,
         const word& name,
         const labelList& cList,
         const label primitiveType,
         const UList<point>& meshPoints,
-        const UList<edge>& edges,
-        const UList<face>& faces,
-        const UList<cell>& cells,
-        const UList<label>& owner
+        const UList<edge>& edges = List<edge>(0),
+        const UList<face>& faces = List<face>(0),
+        const UList<cell>& cells = List<cell>(0),
+        const UList<label>& owner = List<label>(0),
+        const UList<scalar>& scalField = UList<scalar>(),
+        const UList<label>& lablField = UList<label>(),
+        const UList<vector>& vectField = UList<vector>()
     );
 
     // Actual routine to write out the VTK file
-    void writeVTK
+    inline void writeVTK
     (
         const polyMesh& mesh,
         const word& name,
@@ -274,7 +311,10 @@ namespace meshOps
         const labelListList& cpList = labelListList(0),
         const label primitiveType = 3,
         const Map<label>& reversePointMap = Map<label>(),
-        const Map<label>& reverseCellMap = Map<label>()
+        const Map<label>& reverseCellMap = Map<label>(),
+        const UList<scalar>& scalField = UList<scalar>(),
+        const UList<label>& lablField = UList<label>(),
+        const UList<vector>& vectField = UList<vector>()
     );
 
 } // End namespace meshOps
@@ -287,6 +327,10 @@ namespace meshOps
 
 #include "meshOpsI.H"
 
+#ifdef NoRepository
+#    include "meshOps.C"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
index d683bc072..c5e2be0f5 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
@@ -216,8 +216,8 @@ inline label tetApexPoint
 (
     const label cIndex,
     const label fIndex,
-    const UList<face> faces,
-    const UList<cell> cells
+    const UList<face>& faces,
+    const UList<cell>& cells
 )
 {
     label apexPoint = -1;
@@ -241,13 +241,13 @@ inline label tetApexPoint
 
     if (!foundApex)
     {
-        Info << "fIndex: " << fIndex << ":: " << faces[fIndex] << endl;
-        Info << "cIndex: " << cIndex << ":: " << cellToCheck << endl;
+        Pout<< "fIndex: " << fIndex << ":: " << faces[fIndex] << endl;
+        Pout<< "cIndex: " << cIndex << ":: " << cellToCheck << endl;
 
         forAll(cellToCheck, faceI)
         {
-            Info << '\t' << cellToCheck[faceI] << ":: "
-                 << faces[cellToCheck[faceI]] << endl;
+            Pout<< '\t' << cellToCheck[faceI] << ":: "
+                << faces[cellToCheck[faceI]] << endl;
         }
 
         FatalErrorIn
@@ -257,8 +257,8 @@ inline label tetApexPoint
             "(\n"
             "    const label cIndex,\n"
             "    const label fIndex,\n"
-            "    const UList<face> faces,\n"
-            "    const UList<cell> cells\n"
+            "    const UList<face>& faces,\n"
+            "    const UList<cell>& cells\n"
             ")\n"
         )
             << "Could not find an apex point in cell: " << cIndex
@@ -272,7 +272,7 @@ inline label tetApexPoint
 
 // Given a cell index, find the centroid / volume of a cell.
 //  - If checking is enabled, return whether the cell is closed
-inline bool cellCentreAndVolume
+inline void cellCentreAndVolume
 (
     const label cIndex,
     const vectorField& points,
@@ -280,8 +280,7 @@ inline bool cellCentreAndVolume
     const UList<cell>& cells,
     const UList<label>& owner,
     vector& centre,
-    scalar& volume,
-    bool checkClosed
+    scalar& volume
 )
 {
     // Reset inputs
@@ -291,18 +290,12 @@ inline bool cellCentreAndVolume
     const cell& cellToCheck = cells[cIndex];
 
     // Average face-centres to get an estimate centroid
-    vector cEst(vector::zero), fCentre(vector::zero), fArea(vector::zero);
-    vector sumClosed(vector::zero), sumMagClosed(vector::zero);
+    vector cEst(vector::zero), fCentre(vector::zero);
 
     forAll(cellToCheck, faceI)
     {
         const face& checkFace = faces[cellToCheck[faceI]];
 
-        if (checkFace.empty())
-        {
-            continue;
-        }
-
         cEst += checkFace.centre(points);
     }
 
@@ -312,93 +305,82 @@ inline bool cellCentreAndVolume
     {
         const face& checkFace = faces[cellToCheck[faceI]];
 
-        if (checkFace.empty())
+        if (checkFace.size() == 3)
         {
-            continue;
-        }
-
-        fArea = checkFace.normal(points);
-        fCentre = checkFace.centre(points);
-
-        // Flip if necessary
-        if (owner[cellToCheck[faceI]] != cIndex)
-        {
-            fArea *= -1.0;
-        }
-
-        // Calculate 3*face-pyramid volume
-        scalar pyr3Vol = fArea & (fCentre - cEst);
-
-        // Calculate face-pyramid centre
-        vector pc = ((3.0 / 4.0) * fCentre) + ((1.0 / 4.0) * cEst);
-
-        // Accumulate volume-weighted face-pyramid centre
-        centre += pyr3Vol*pc;
-
-        // Accumulate face-pyramid volume
-        volume += pyr3Vol;
-
-        // Accumulate areas, if necessary
-        if (checkClosed)
-        {
-            sumClosed += fArea;
-            sumMagClosed += cmptMag(fArea);
-        }
-    }
-
-    centre /= volume + VSMALL;
-    volume *= (1.0 / 3.0);
-
-    if (checkClosed)
-    {
-        // Check the sum across components
-        scalar closed = 0.0;
-
-        for (direction cmpt = 0; cmpt < vector::nComponents; cmpt++)
-        {
-            closed =
+            tetPointRef tpr
             (
-                mag(sumClosed[cmpt]) / (sumMagClosed[cmpt] + VSMALL)
+                points[checkFace[2]],
+                points[checkFace[1]],
+                points[checkFace[0]],
+                cEst
             );
 
-            if (closed > 1e-06)
+            scalar tetVol = tpr.mag();
+
+            // Flip if necessary
+            if (owner[cellToCheck[faceI]] != cIndex)
             {
-                // Volume is invalid
-                return false;
+                tetVol *= -1.0;
+            }
+
+            // Accumulate volume-weighted tet centre
+            centre += tetVol*tpr.centre();
+
+            // Accumulate tet volume
+            volume += tetVol;
+        }
+        else
+        {
+            forAll(checkFace, pI)
+            {
+                tetPointRef tpr
+                (
+                    points[checkFace[pI]],
+                    points[checkFace.prevLabel(pI)],
+                    checkFace.centre(points),
+                    cEst
+                );
+
+                scalar tetVol = tpr.mag();
+
+                // Flip if necessary
+                if (owner[cellToCheck[faceI]] != cIndex)
+                {
+                    tetVol *= -1.0;
+                }
+
+                // Accumulate volume-weighted tet centre
+                centre += tetVol*tpr.centre();
+
+                // Accumulate tet volume
+                volume += tetVol;
             }
         }
     }
 
-    // Volume is valid
-    return true;
+    centre /= volume + VSMALL;
 }
 
 
 // Determine whether a segment intersects a triangular face
-template <class T>
 inline bool segmentTriFaceIntersection
 (
-    const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
-    const line<Vector<T>, const Vector<T>&>& edgeToCheck,
-    const T& matchTol,
-    Vector<T>& intPoint
+    const triPointRef& faceToCheck,
+    const linePointRef& edgeToCheck,
+    vector& intPoint
 )
 {
     // Fetch references
-    const Vector<T>& p1 = edgeToCheck.start();
-    const Vector<T>& p2 = edgeToCheck.end();
+    const vector& p1 = edgeToCheck.start();
+    const vector& p2 = edgeToCheck.end();
 
-    const Vector<T>& a = faceToCheck.a();
-    const Vector<T>& b = faceToCheck.b();
-    const Vector<T>& c = faceToCheck.c();
-
-    // Define custom face-normal
-    Vector<T> n = (T(0.5) * ((b - a)^(c - a)));
+    // Define face-normal
+    vector n = faceToCheck.normal();
     n /= mag(n) + VSMALL;
 
     // Compute uValue
-    T numerator = n & (a - p1);
-    T denominator = n & (p2 - p1);
+    scalar numerator = n & (faceToCheck.a() - p1);
+    scalar denominator = n & (p2 - p1);
 
     // Check if the edge is parallel to the face
     if (mag(denominator) < VSMALL)
@@ -406,17 +388,16 @@ inline bool segmentTriFaceIntersection
         return false;
     }
 
-    T u = (numerator / denominator);
-    T tolerance = (matchTol * mag(p2 - p1));
+    scalar u = (numerator / denominator);
 
     // Check for intersection along line.
-    if ((u > tolerance) && (u < (pTraits<T>::one - tolerance)))
+    if ((u >= 0.0) && (u <= 1.0))
     {
         // Compute point of intersection
         intPoint = p1 + u*(p2 - p1);
 
         // Also make sure that intPoint lies within the face
-        if (pointInTriFace(faceToCheck, intPoint, matchTol, false))
+        if (pointInTriFace(faceToCheck, intPoint, false))
         {
             return true;
         }
@@ -429,49 +410,45 @@ inline bool segmentTriFaceIntersection
 
 // Determine whether the particular point lies
 // inside the given triangular face
-template <class T>
 inline bool pointInTriFace
 (
-    const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
-    const Vector<T>& cP,
-    const T& matchTol,
+    const triPointRef& faceToCheck,
+    const vector& cP,
     bool testCoplanarity
 )
 {
     // Copy inputs
-    const Vector<T>& a = faceToCheck.a();
-    const Vector<T>& b = faceToCheck.b();
-    const Vector<T>& c = faceToCheck.c();
-
-    const T pointFive(0.5);
+    const vector& a = faceToCheck.a();
+    const vector& b = faceToCheck.b();
+    const vector& c = faceToCheck.c();
 
     // Compute the normal
-    Vector<T> nf = (pointFive * ((b - a)^(c - a)));
+    vector nf = faceToCheck.normal();
 
-    if ( ((pointFive * ((b - a)^(cP - a))) & nf) < pTraits<T>::zero)
+    if ( ((0.5 * ((b - a)^(cP - a))) & nf) < 0.0)
     {
         return false;
     }
 
-    if ( ((pointFive * ((c - b)^(cP - b))) & nf) < pTraits<T>::zero)
+    if ( ((0.5 * ((c - b)^(cP - b))) & nf) < 0.0)
     {
         return false;
     }
 
-    if ( ((pointFive * ((a - c)^(cP - c))) & nf) < pTraits<T>::zero)
+    if ( ((0.5 * ((a - c)^(cP - c))) & nf) < 0.0)
     {
         return false;
     }
 
     if (testCoplanarity)
     {
-        Vector<T> ftp(a - cP);
+        vector ftp(a - cP);
 
         // Normalize vectors
         nf /= mag(nf) + VSMALL;
         ftp /= mag(ftp) + VSMALL;
 
-        if (mag(ftp & nf) > matchTol)
+        if (mag(ftp & nf) > VSMALL)
         {
             return false;
         }
@@ -482,53 +459,120 @@ inline bool pointInTriFace
 }
 
 
-// Method to insert labels in a face, so that
-// right-handedness is preserved.
-template <class T>
-inline void insertPointLabels
+// Parallel blocking send
+inline void pWrite
 (
-    const Vector<T>& refNorm,
-    const Field<Vector<T> >& points,
-    const labelHashSet& pLabels,
-    face& modFace
+    const label toID,
+    const label& data
 )
 {
-    // Need to configure a new face.
-    face newFace(modFace);
+    OPstream::write
+    (
+        Pstream::blocking,
+        toID,
+        reinterpret_cast<const char*>(&data),
+        sizeof(label)
+    );
+}
 
-    const T pointFive(0.5);
 
-    forAllConstIter(labelHashSet, pLabels, pIter)
+// Parallel blocking receive
+inline void pRead
+(
+    const label fromID,
+    label& data
+)
+{
+    IPstream::read
+    (
+        Pstream::blocking,
+        fromID,
+        reinterpret_cast<char*>(&data),
+        sizeof(label)
+    );
+}
+
+
+// Parallel non-blocking send for fixed lists
+template <class Type, unsigned Size>
+inline void pWrite
+(
+    const label toID,
+    const FixedList<Type, Size>& data
+)
+{
+    OPstream::write
+    (
+        Pstream::blocking,
+        toID,
+        reinterpret_cast<const char*>(&data[0]),
+        Size*sizeof(Type)
+    );
+}
+
+
+// Parallel non-blocking receive for fixed lists
+template <class Type, unsigned Size>
+inline void pRead
+(
+    const label fromID,
+    FixedList<Type, Size>& data
+)
+{
+    IPstream::read
+    (
+        Pstream::blocking,
+        fromID,
+        reinterpret_cast<char*>(data.begin()),
+        Size*sizeof(Type)
+    );
+}
+
+
+// Parallel non-blocking send for lists
+template <class Type>
+inline void pWrite
+(
+    const label toID,
+    const UList<Type>& data
+)
+{
+    OPstream::write
+    (
+        Pstream::nonBlocking,
+        toID,
+        reinterpret_cast<const char*>(&data[0]),
+        data.size()*sizeof(Type)
+    );
+}
+
+
+// Parallel non-blocking receive for lists
+template <class Type>
+inline void pRead
+(
+    const label fromID,
+    UList<Type>& data
+)
+{
+    IPstream::read
+    (
+        Pstream::nonBlocking,
+        fromID,
+        reinterpret_cast<char*>(&data[0]),
+        data.size()*sizeof(Type)
+    );
+}
+
+
+// Wait for buffer transfer completion.
+inline void waitForBuffers()
+{
+    if (Pstream::parRun())
     {
-        forAll(newFace, pI)
-        {
-            label nI = newFace.fcIndex(pI);
-
-            const Vector<T>& a = points[newFace[pI]];
-            const Vector<T>& b = points[pIter.key()];
-            const Vector<T>& c = points[newFace[nI]];
-
-            // Compute the normal.
-            Vector<T> newNorm = (pointFive * ((b - a)^(c - a)));
-
-            if ((refNorm & newNorm) > pTraits<T>::zero)
-            {
-                // Insert the point.
-                meshOps::insertLabel
-                (
-                    pIter.key(),
-                    newFace[pI],
-                    newFace[nI],
-                    newFace
-                );
-
-                break;
-            }
-        }
+        OPstream::waitRequests();
+        IPstream::waitRequests();
     }
-
-    // Take over storage
-    modFace.transfer(newFace);
 }