diff --git a/src/dynamicMesh/Allwmake b/src/dynamicMesh/Allwmake
index 67830a8e4..195ad699e 100755
--- a/src/dynamicMesh/Allwmake
+++ b/src/dynamicMesh/Allwmake
@@ -7,7 +7,9 @@ wmake libso dynamicMesh
 # Make meshMotion solvers
 meshMotion/Allwmake
 
-wmake libso dynamicFvMesh
+# Make libraries in dynamicFvMesh
+dynamicFvMesh/Allwmake
+
 wmake libso topoChangerFvMesh
 
 # ----------------------------------------------------------------- end-of-file
diff --git a/src/dynamicMesh/dynamicFvMesh/Allwclean b/src/dynamicMesh/dynamicFvMesh/Allwclean
new file mode 100755
index 000000000..0db6608b5
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/Allwclean
@@ -0,0 +1,12 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+# Clean dynamicFvMesh libraries
+wclean
+wclean dynamicTopoFvMesh
+
+# Wipe out all lnInclude directories and re-link
+wcleanLnIncludeAll
+
+# ----------------------------------------------------------------- end-of-file
diff --git a/src/dynamicMesh/dynamicFvMesh/Allwmake b/src/dynamicMesh/dynamicFvMesh/Allwmake
new file mode 100755
index 000000000..0296a437e
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/Allwmake
@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+# Make dynamicFvMesh libraries
+wmake libso
+wmake libso dynamicTopoFvMesh
+
+# ----------------------------------------------------------------- end-of-file
diff --git a/src/dynamicMesh/dynamicFvMesh/Make/files b/src/dynamicMesh/dynamicFvMesh/Make/files
index 25ed01415..46aee8b5e 100644
--- a/src/dynamicMesh/dynamicFvMesh/Make/files
+++ b/src/dynamicMesh/dynamicFvMesh/Make/files
@@ -17,42 +17,4 @@ turboFvMesh/turboFvMesh.C
 fvMeshAdder/fvMeshAdder.C
 fvMeshDistribute/fvMeshDistribute.C
 
-tetMetrics = dynamicTopoFvMesh/tetMetrics
-$(tetMetrics)/tetMetric.C
-$(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/dynamicTopoFvMeshCoupled.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
-
 LIB = $(FOAM_LIBBIN)/libdynamicFvMesh
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/files b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/files
new file mode 100644
index 000000000..c8d77fa87
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/files
@@ -0,0 +1,39 @@
+eMesh/eMesh.C
+eMesh/eMeshDemandDrivenData.C
+eMesh/eBoundaryMesh/eBoundaryMesh.C
+
+ePatches = eMesh/ePatches
+$(ePatches)/ePatch/ePatch.C
+$(ePatches)/ePatch/newEPatch.C
+
+dynamicTopoFvMesh.C
+dynamicTopoFvMeshCheck.C
+dynamicTopoFvMeshReOrder.C
+dynamicTopoFvMeshMapping.C
+edgeSwap.C
+edgeBisect.C
+edgeCollapse.C
+
+coupledMesh/coupleMap.C
+coupledMesh/dynamicTopoFvMeshCoupled.C
+coupledMesh/subMeshProcessorPolyPatch.C
+coupledMesh/subMeshProcessorFvPatch.C
+
+convexSetAlgorithm/convexSetAlgorithm.C
+convexSetAlgorithm/faceSetAlgorithm.C
+convexSetAlgorithm/cellSetAlgorithm.C
+
+fieldMapping/topoMapper.C
+fieldMapping/fluxCorrector.C
+fieldMapping/topoCellMapper.C
+fieldMapping/topoPatchMapper.C
+fieldMapping/topoSurfaceMapper.C
+
+tetMetrics = tetMetrics
+$(tetMetrics)/tetMetric.C
+$(tetMetrics)/tetMetrics.C
+
+lengthScaleEstimator = lengthScaleEstimator
+$(lengthScaleEstimator)/lengthScaleEstimator.C
+
+LIB = $(FOAM_LIBBIN)/libdynamicTopoFvMesh
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/options b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/options
new file mode 100644
index 000000000..c276d3ba5
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/Make/options
@@ -0,0 +1,13 @@
+EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/dynamicFvMesh \
+    -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/fvMeshDistribute \
+    -I$(LIB_SRC)/decompositionMethods/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+
+LIB_LIBS = \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
+    -ldecompositionMethods \
+    -lfiniteVolume
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
index 46f6de305..b9f73f8b1 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/convexSetAlgorithm/convexSetAlgorithm.C
@@ -34,7 +34,6 @@ Author
 
 \*---------------------------------------------------------------------------*/
 
-#include "objectRegistry.H"
 #include "Time.H"
 #include "IOMap.H"
 #include "meshOps.H"
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C
deleted file mode 100644
index 5eb931ab2..000000000
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.C
+++ /dev/null
@@ -1,647 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | foam-extend: Open Source CFD
-   \\    /   O peration     |
-    \\  /    A nd           | For copyright notice see file Copyright
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of foam-extend.
-
-    foam-extend is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation, either version 3 of the License, or (at your
-    option) any later version.
-
-    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#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/coupleMap.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.C
similarity index 86%
rename from src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C
rename to src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.C
index 8ec7600b2..a34880dfa 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.C
@@ -52,6 +52,7 @@ const char* coupleMap::names[coupleMap::INVALID + 1] =
     "REMOVE_CELL",
     "MOVE_POINT",
     "CONVERT_PATCH",
+    "CONVERT_PHYSICAL",
     "INVALID"
 };
 
@@ -204,8 +205,8 @@ void coupleMap::makeFaces() const
         face& f = faces[faceI];
         labelList& fe = faceEdges[faceI];
 
-        // Fetch the buffer value for 2D meshes
-        label nfe = twoDMesh_ ? nfeBuffer[faceI] : 3;
+        // Fetch the buffer value
+        label nfe = nfeBuffer[faceI];
 
         // Size up the lists
         f.setSize(nfe, -1);
@@ -279,6 +280,22 @@ void coupleMap::makeCellMap() const
 }
 
 
+void coupleMap::makeInternalFaceMap() const
+{
+    // It is an error to attempt to recalculate
+    // if the map is already calculated
+    if (internalFaceMap_.size())
+    {
+        FatalErrorIn("void coupleMap::makeInternalFaceMap() const")
+            << "internal faceMap has already been calculated."
+            << abort(FatalError);
+    }
+
+    // Slice for internal faces
+    internalFaceMap_ = SubList<label>(faceMap(), nEntities(INTERNAL_FACE));
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 pointField& coupleMap::pointBuffer() const
@@ -343,12 +360,8 @@ void coupleMap::allocateBuffers() const
     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));
-    }
+    // Set face-sizes
+    entityBuffer(NFE_BUFFER).setSize(nEntities(FACE));
 
     // Allocate for variable size face-lists
     entityBuffer(FACE).setSize(nEntities(NFE_SIZE));
@@ -446,6 +459,43 @@ void coupleMap::mapMaster
 }
 
 
+void coupleMap::pushOperation
+(
+    const label index,
+    const opType oType
+) const
+{
+    entityIndices_.setSize(entityIndices_.size() + 1, index);
+    entityOperations_.setSize(entityOperations_.size() + 1, oType);
+}
+
+
+void coupleMap::pushOperation
+(
+    const label index,
+    const opType oType,
+    const label pIndex
+) const
+{
+    if (oType == coupleMap::CONVERT_PHYSICAL)
+    {
+        entityIndices_.setSize(entityIndices_.size() + 1, index);
+        entityOperations_.setSize(entityOperations_.size() + 1, oType);
+
+        patchIndices_.setSize(patchIndices_.size() + 1, pIndex);
+    }
+    else
+    {
+        opType t = (oType < coupleMap::INVALID ? oType : coupleMap::INVALID);
+
+        FatalErrorIn("void coupleMap::pushOperation() const")
+            << " Expected CONVERT_PHYSICAL" << nl
+            << " Found: " << coupleMap::names[t]
+            << abort(FatalError);
+    }
+}
+
+
 void coupleMap::pushOperation
 (
     const label index,
@@ -466,6 +516,15 @@ void coupleMap::pushOperation
         moveNewPoints_.setSize(moveNewPoints_.size() + 1, newPoint);
         moveOldPoints_.setSize(moveOldPoints_.size() + 1, oldPoint);
     }
+    else
+    {
+        opType t = (oType < coupleMap::INVALID ? oType : coupleMap::INVALID);
+
+        FatalErrorIn("void coupleMap::pushOperation() const")
+            << " Expected either MOVE_POINT or CONVERT_PATCH" << nl
+            << " Found: " << coupleMap::names[t]
+            << abort(FatalError);
+    }
 }
 
 
@@ -485,6 +544,10 @@ void coupleMap::clearMaps() const
 {
     faceMap_.clear();
     cellMap_.clear();
+    internalFaceMap_.clear();
+
+    subMeshPointMap_.clear();
+    subMeshEdgeMap_.clear();
 
     forAll(entityMap_, mapI)
     {
@@ -510,6 +573,7 @@ void coupleMap::clearBuffers() const
     entityIndices_.clear();
     entityOperations_.clear();
 
+    patchIndices_.clear();
     moveNewPoints_.clear();
     moveOldPoints_.clear();
 }
@@ -588,6 +652,17 @@ const labelList& coupleMap::cellMap() const
 }
 
 
+const labelList& coupleMap::internalFaceMap() const
+{
+    if (internalFaceMap_.empty())
+    {
+        makeInternalFaceMap();
+    }
+
+    return internalFaceMap_;
+}
+
+
 bool coupleMap::readData(Istream& is)
 {
     Map<label> tmpMap(is);
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.H
similarity index 79%
rename from src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H
rename to src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.H
index a9f5541fc..15ee98c8b 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMap.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMap.H
@@ -73,42 +73,51 @@ public:
         enum entityType
         {
             // Buffers and sizes
-            POINT = 0,
-            EDGE = 1,
-            FACE = 2,
+            POINT         = 0,
+            EDGE          = 1,
+            FACE          = 2,
             // Sizes only
-            CELL = 3,
+            CELL          = 3,
+            MAX_ENTITIES  = 4,
             INTERNAL_EDGE = 4,
             INTERNAL_FACE = 5,
-            SHARED_POINT = 6,
-            GLOBAL_POINT = 7,
-            NFE_SIZE = 8,
-            NBDY = 9,
+            SHARED_POINT  = 6,
+            GLOBAL_POINT  = 7,
+            NFE_SIZE      = 8,
+            NBDY          = 9,
+            MAX_SIZES     = 10,
             // 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
+            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,
+            MAX_BUFFERS   = 12
         };
 
         //- Enumerants for operations
         enum opType
         {
-            BISECTION = 0,
-            COLLAPSE_FIRST = 1,
-            COLLAPSE_SECOND = 2,
+            BISECTION         = 0,
+            COLLAPSE_FIRST    = 1,
+            COLLAPSE_SECOND   = 2,
             COLLAPSE_MIDPOINT = 3,
-            REMOVE_CELL = 4,
-            MOVE_POINT = 5,
-            CONVERT_PATCH = 6,
+            REMOVE_CELL       = 4,
+            MOVE_POINT        = 5,
+            CONVERT_PATCH     = 6,
+            CONVERT_PHYSICAL  = 7,
             INVALID
         };
 
+        //- Public typedefs
+        typedef FixedList<label, MAX_SIZES> EntitySizeList;
+        typedef FixedList<Map<label>, MAX_ENTITIES> EntityMapList;
+        typedef FixedList<labelList, MAX_BUFFERS> EntityBufferList;
+
 private:
 
     // Private data
@@ -136,14 +145,14 @@ private:
         mutable List<labelPair> globalProcPoints_;
 
         // Entity sizes (as specified by the entityType enumerant)
-        mutable FixedList<label,10> nEntities_;
+        mutable EntitySizeList nEntities_;
 
         // Maps for entities
-        mutable FixedList<Map<label>,4> entityMap_;
-        mutable FixedList<Map<label>,4> reverseEntityMap_;
+        mutable EntityMapList entityMap_;
+        mutable EntityMapList reverseEntityMap_;
 
         // Entity Buffers (as specified by the entityType enumerant)
-        mutable FixedList<labelList,12> entityBuffer_;
+        mutable EntityBufferList entityBuffer_;
 
         // List of entity indices with topological operations
         mutable labelList entityIndices_;
@@ -151,6 +160,9 @@ private:
         // List of operations performed on entities
         mutable List<opType> entityOperations_;
 
+        // Physical patch conversion indices
+        mutable labelList patchIndices_;
+
         // List of point-locations to move points to
         mutable pointField moveNewPoints_;
         mutable pointField moveOldPoints_;
@@ -158,17 +170,25 @@ private:
         // Addressing for field mapping
         mutable labelList faceMap_;
         mutable labelList cellMap_;
+        mutable labelList internalFaceMap_;
+
+        // Processor point and edge mapping
+        mutable Map<labelList> subMeshPointMap_;
+        mutable Map<labelList> subMeshEdgeMap_;
 
         //- Demand-driven connectivity data.
         mutable edgeList* edgesPtr_;
         mutable faceList* facesPtr_;
         mutable labelListList* faceEdgesPtr_;
 
+    // Private Member Functions
+
         void makeEdges() const;
         void makeFaces() const;
 
         void makeFaceMap() const;
         void makeCellMap() const;
+        void makeInternalFaceMap() const;
 
         void clearAddressing() const;
 
@@ -311,27 +331,44 @@ public:
             const label master
         ) const;
 
-        inline FixedList<label,10>& nEntities() const;
+        inline EntitySizeList& 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 EntityBufferList& entityBuffer() const;
         inline labelList& entityBuffer(const label eType) const;
 
         inline labelList& entityIndices() const;
         inline List<opType>& entityOperations() const;
 
+        inline labelList& patchIndices() const;
         inline pointField& moveNewPoints() const;
         inline pointField& moveOldPoints() const;
 
+        inline Map<labelList>& subMeshPointMap() const;
+        inline Map<labelList>& subMeshEdgeMap() const;
+
+        void pushOperation
+        (
+            const label index,
+            const opType oType
+        ) const;
+
         void pushOperation
         (
             const label index,
             const opType oType,
-            const point& newPoint = vector::zero,
-            const point& oldPoint = vector::zero
+            const label pIndex
+        ) const;
+
+        void pushOperation
+        (
+            const label index,
+            const opType oType,
+            const point& newPoint,
+            const point& oldPoint
         ) const;
 
         //- Demand-driven data
@@ -344,6 +381,7 @@ public:
 
         const labelList& faceMap() const;
         const labelList& cellMap() const;
+        const labelList& internalFaceMap() const;
 
         void transferMaps
         (
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMapI.H
similarity index 93%
rename from src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H
rename to src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMapI.H
index 365a651f3..60505d5a1 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupleMapI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupleMapI.H
@@ -222,7 +222,7 @@ inline bool coupleMap::isRecv() const
 }
 
 
-inline FixedList<label,10>& coupleMap::nEntities() const
+inline coupleMap::EntitySizeList& coupleMap::nEntities() const
 {
     return nEntities_;
 }
@@ -246,7 +246,7 @@ inline Map<label>& coupleMap::reverseEntityMap(const label eType) const
 }
 
 
-inline FixedList<labelList,12>& coupleMap::entityBuffer() const
+inline coupleMap::EntityBufferList& coupleMap::entityBuffer() const
 {
     return entityBuffer_;
 }
@@ -270,6 +270,12 @@ inline List<coupleMap::opType>& coupleMap::entityOperations() const
 }
 
 
+inline labelList& coupleMap::patchIndices() const
+{
+    return patchIndices_;
+}
+
+
 inline pointField& coupleMap::moveNewPoints() const
 {
     return moveNewPoints_;
@@ -282,6 +288,18 @@ inline pointField& coupleMap::moveOldPoints() const
 }
 
 
+inline Map<labelList>& coupleMap::subMeshPointMap() const
+{
+    return subMeshPointMap_;
+}
+
+
+inline Map<labelList>& coupleMap::subMeshEdgeMap() const
+{
+    return subMeshEdgeMap_;
+}
+
+
 } // End namespace Foam
 
 // ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.C
new file mode 100644
index 000000000..473b2b2f7
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.C
@@ -0,0 +1,747 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Time.H"
+#include "coupledInfo.H"
+#include "emptyPolyPatch.H"
+#include "processorPolyPatch.H"
+#include "fixedValueFvPatchFields.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct given mesh, coupleMap and master / slave indices
+template <class MeshType>
+coupledInfo<MeshType>::coupledInfo
+(
+    const MeshType& mesh,
+    const coupleMap& cMap,
+    const label mfzIndex,
+    const label sfzIndex
+)
+:
+    mesh_(mesh),
+    builtMaps_(false),
+    map_(cMap),
+    masterFaceZone_(mfzIndex),
+    slaveFaceZone_(sfzIndex)
+{}
+
+
+// Construct from components
+template <class MeshType>
+coupledInfo<MeshType>::coupledInfo
+(
+    const MeshType& 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
+template <class MeshType>
+coupledInfo<MeshType>::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  * * * * * * * * * * * * * //
+
+// Return a const reference to the parent mesh
+template <class MeshType>
+const MeshType&
+coupledInfo<MeshType>::baseMesh() const
+{
+    return mesh_;
+}
+
+
+// Set a new subMesh
+template <class MeshType>
+void coupledInfo<MeshType>::setMesh
+(
+    label index,
+    MeshType* mesh
+)
+{
+    subMesh_.set(mesh);
+}
+
+
+// Return a reference to the subMesh
+template <class MeshType>
+MeshType& coupledInfo<MeshType>::subMesh()
+{
+    if (!subMesh_.valid())
+    {
+        FatalErrorIn("MeshType& coupledInfo::subMesh()")
+            << " Sub-mesh pointer has not been set."
+            << abort(FatalError);
+    }
+
+    return subMesh_();
+}
+
+
+// Return a const reference to the subMesh
+template <class MeshType>
+const MeshType& coupledInfo<MeshType>::subMesh() const
+{
+    if (!subMesh_.valid())
+    {
+        FatalErrorIn("const MeshType& coupledInfo::subMesh() const")
+            << " Sub-mesh pointer has not been set."
+            << abort(FatalError);
+    }
+
+    return subMesh_();
+}
+
+
+// Return if maps have been built
+template <class MeshType>
+bool coupledInfo<MeshType>::builtMaps() const
+{
+    return builtMaps_;
+}
+
+
+// Set internal state of maps as built
+template <class MeshType>
+void coupledInfo<MeshType>::setBuiltMaps()
+{
+    builtMaps_ = true;
+}
+
+
+// Return a reference to the coupleMap
+template <class MeshType>
+coupleMap& coupledInfo<MeshType>::map()
+{
+    return map_;
+}
+
+
+// Return a const reference to the coupleMap
+template <class MeshType>
+const coupleMap& coupledInfo<MeshType>::map() const
+{
+    return map_;
+}
+
+
+// Return the master face zone ID
+template <class MeshType>
+label coupledInfo<MeshType>::masterFaceZone() const
+{
+    return masterFaceZone_;
+}
+
+
+// Return the slave face zone ID
+template <class MeshType>
+label coupledInfo<MeshType>::slaveFaceZone() const
+{
+    return slaveFaceZone_;
+}
+
+
+// Subset geometric field
+template <class MeshType>
+template <class GeomField, class ZeroType>
+tmp<GeomField>
+coupledInfo<MeshType>::subSetField
+(
+    const GeomField& f,
+    const ZeroType& zeroValue,
+    const labelList& internalMapper
+) const
+{
+    typedef typename GeomField::InternalField InternalField;
+    typedef typename GeomField::PatchFieldType PatchFieldType;
+    typedef typename GeomField::GeometricBoundaryField GeomBdyFieldType;
+    typedef typename GeomField::DimensionedInternalField DimInternalField;
+
+    // Create and map the internal-field values
+    InternalField internalField(f.internalField(), internalMapper);
+
+    // Create and map the patch field values
+    label nPatches = subMesh().boundary().size();
+    PtrList<PatchFieldType> patchFields(nPatches);
+
+    // Define patch type names, assumed to be
+    // common for volume and surface fields
+    word emptyType(emptyPolyPatch::typeName);
+    word processorType(processorPolyPatch::typeName);
+
+    // Create dummy types for initial field creation
+    forAll(patchFields, patchI)
+    {
+        if (patchI == (nPatches - 1))
+        {
+            // Artificially set last patch
+            patchFields.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    emptyType,
+                    subMesh().boundary()[patchI],
+                    DimInternalField::null()
+                )
+            );
+        }
+        else
+        {
+            patchFields.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    PatchFieldType::calculatedType(),
+                    subMesh().boundary()[patchI],
+                    DimInternalField::null()
+                )
+            );
+        }
+    }
+
+    // Create new field from pieces
+    tmp<GeomField> subFld
+    (
+        new GeomField
+        (
+            IOobject
+            (
+                "subField_" + f.name(),
+                subMesh().time().timeName(),
+                subMesh(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            subMesh(),
+            f.dimensions(),
+            internalField,
+            patchFields
+        )
+    );
+
+    // Set correct references for patch internal fields,
+    // and map values from the supplied geometric field
+    GeomBdyFieldType& bf = subFld().boundaryField();
+
+    forAll(bf, patchI)
+    {
+        if (patchI == (nPatches - 1))
+        {
+            // Artificially set last patch
+            bf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    emptyType,
+                    subMesh().boundary()[patchI],
+                    subFld().dimensionedInternalField()
+                )
+            );
+        }
+        else
+        if (isA<processorPolyPatch>(subMesh().boundary()[patchI].patch()))
+        {
+            bf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    processorType,
+                    subMesh().boundary()[patchI],
+                    subFld().dimensionedInternalField()
+                )
+            );
+
+            // Avoid dealing with uninitialised values
+            // by artificially assigning to zero
+            bf[patchI] == zeroValue;
+        }
+        else
+        {
+            bf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    f.boundaryField()[patchI],
+                    subMesh().boundary()[patchI],
+                    subFld().dimensionedInternalField(),
+                    subMeshMapper(*this, patchI)
+                )
+            );
+        }
+    }
+
+    return subFld;
+}
+
+
+// Subset geometric fields from registry to output stream
+template <class MeshType>
+template <class GeomField, class ZeroType>
+void coupledInfo<MeshType>::send
+(
+    const wordList& fieldNames,
+    const word& fieldType,
+    const ZeroType& zeroValue,
+    const labelList& internalMapper,
+    OSstream& strStream
+) const
+{
+    strStream
+        << fieldType << token::NL
+        << token::BEGIN_BLOCK << token::NL;
+
+    forAll(fieldNames, i)
+    {
+        // Fetch object from registry
+        const objectRegistry& db = mesh_.thisDb();
+
+        const GeomField& fld = db.lookupObject<GeomField>(fieldNames[i]);
+
+        // Subset the field
+        tmp<GeomField> tsubFld = subSetField(fld, zeroValue, internalMapper);
+
+        // Send field subset 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 geometric field pointers from input dictionary
+template <class MeshType>
+template <class GeomField>
+void coupledInfo<MeshType>::setField
+(
+    const wordList& fieldNames,
+    const dictionary& fieldDicts,
+    const label internalSize,
+    PtrList<GeomField>& fields
+) const
+{
+    typedef typename GeomField::InternalField InternalField;
+    typedef typename GeomField::PatchFieldType PatchFieldType;
+    typedef typename GeomField::GeometricBoundaryField GeomBdyFieldType;
+    typedef typename GeomField::DimensionedInternalField DimInternalField;
+
+    // Size up the pointer list
+    fields.setSize(fieldNames.size());
+
+    // Define patch type names, assumed to be
+    // common for volume and surface fields
+    word emptyType(emptyPolyPatch::typeName);
+    word processorType(processorPolyPatch::typeName);
+
+    forAll(fieldNames, i)
+    {
+        // Create and map the patch field values
+        label nPatches = subMesh().boundary().size();
+
+        // Create field parts
+        PtrList<PatchFieldType> patchFields(nPatches);
+
+        // Read dimensions
+        dimensionSet dimSet
+        (
+            fieldDicts.subDict(fieldNames[i]).lookup("dimensions")
+        );
+
+        // Read the internal field
+        InternalField internalField
+        (
+            "internalField",
+            fieldDicts.subDict(fieldNames[i]),
+            internalSize
+        );
+
+        // Create dummy types for initial field creation
+        forAll(patchFields, patchI)
+        {
+            if (patchI == (nPatches - 1))
+            {
+                // Artificially set last patch
+                patchFields.set
+                (
+                    patchI,
+                    PatchFieldType::New
+                    (
+                        emptyType,
+                        subMesh().boundary()[patchI],
+                        DimInternalField::null()
+                    )
+                );
+            }
+            else
+            {
+                patchFields.set
+                (
+                    patchI,
+                    PatchFieldType::New
+                    (
+                        PatchFieldType::calculatedType(),
+                        subMesh().boundary()[patchI],
+                        DimInternalField::null()
+                    )
+                );
+            }
+        }
+
+        // Create field with dummy patches
+        fields.set
+        (
+            i,
+            new GeomField
+            (
+                IOobject
+                (
+                    fieldNames[i],
+                    subMesh().time().timeName(),
+                    subMesh(),
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                subMesh(),
+                dimSet,
+                internalField,
+                patchFields
+            )
+        );
+
+        // Set correct references for patch internal fields,
+        // and fetch values from the supplied geometric field dictionaries
+        GeomBdyFieldType& bf = fields[i].boundaryField();
+
+        forAll(bf, patchI)
+        {
+            if (patchI == (nPatches - 1))
+            {
+                // Artificially set last patch
+                bf.set
+                (
+                    patchI,
+                    PatchFieldType::New
+                    (
+                        emptyType,
+                        subMesh().boundary()[patchI],
+                        fields[i].dimensionedInternalField()
+                    )
+                );
+            }
+            else
+            if (isA<processorPolyPatch>(subMesh().boundary()[patchI].patch()))
+            {
+                bf.set
+                (
+                    patchI,
+                    PatchFieldType::New
+                    (
+                        processorType,
+                        subMesh().boundary()[patchI],
+                        fields[i].dimensionedInternalField()
+                    )
+                );
+            }
+            else
+            {
+                bf.set
+                (
+                    patchI,
+                    PatchFieldType::New
+                    (
+                        subMesh().boundary()[patchI],
+                        fields[i].dimensionedInternalField(),
+                        fieldDicts.subDict
+                        (
+                            fieldNames[i]
+                        ).subDict("boundaryField").subDict
+                        (
+                            subMesh().boundary()[patchI].name()
+                        )
+                    )
+                );
+            }
+        }
+    }
+}
+
+
+// Resize map for individual field
+template <class MeshType>
+template <class GeomField>
+void coupledInfo<MeshType>::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 MeshType>
+template <class GeomField>
+void coupledInfo<MeshType>::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<MeshType>::resizeMap
+        (
+            indexI,
+            internalMapper,
+            internalReverseMaps,
+            boundaryMapper,
+            boundaryReverseMaps,
+            srcFields,
+            field
+        );
+    }
+}
+
+
+// Resize boundaryFields for all fields in the registry
+template <class MeshType>
+template <class GeomField>
+void coupledInfo<MeshType>::resizeBoundaries
+(
+    const objectRegistry& mesh,
+    const fvBoundaryMesh& boundary
+)
+{
+    typedef typename GeomField::PatchFieldType PatchFieldType;
+    typedef typename GeomField::GeometricBoundaryField GeomBoundaryType;
+
+    HashTable<const GeomField*> fields(mesh.lookupClass<GeomField>());
+
+    forAllIter(typename HashTable<const GeomField*>, fields, fIter)
+    {
+        // Fetch field from registry
+        GeomField& field = const_cast<GeomField&>(*fIter());
+
+        GeomBoundaryType& bf = field.boundaryField();
+
+        // Resize boundary
+        label nPatches = boundary.size();
+        label nOldPatches = field.boundaryField().size();
+
+        // Create a new list of boundaries
+        PtrList<PatchFieldType> newbf(nPatches);
+
+        // Existing fields are mapped with new fvBoundaryMesh references
+        for (label patchI = 0; patchI < nOldPatches; patchI++)
+        {
+            label oldPatchSize = bf[patchI].size();
+
+            newbf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    bf[patchI],
+                    boundary[patchI],
+                    field,
+                    subMeshMapper(oldPatchSize, identity(oldPatchSize))
+                )
+            );
+        }
+
+        // Size up new patches
+        for (label patchI = nOldPatches; patchI < nPatches; patchI++)
+        {
+            newbf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    boundary[patchI].type(),
+                    boundary[patchI],
+                    field
+                )
+            );
+        }
+
+        // Transfer contents with new patches
+        bf.transfer(newbf);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+// Disallow default bitwise assignment
+template <class MeshType>
+void coupledInfo<MeshType>::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/coupledMesh/coupledInfo.H
similarity index 68%
rename from src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H
rename to src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.H
index b07366b29..12950744f 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledInfo.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/coupledInfo.H
@@ -43,83 +43,91 @@ SourceFiles
 #include "autoPtr.H"
 #include "coupleMap.H"
 #include "volFieldsFwd.H"
-#include "surfaceFieldsFwd.H"
 #include "fvPatchFieldMapper.H"
 
 namespace Foam
 {
 
 // Class forward declarations
-class dynamicTopoFvMesh;
+class fvBoundaryMesh;
 
 /*---------------------------------------------------------------------------*\
                          Class coupledInfo Declaration
 \*---------------------------------------------------------------------------*/
 
+template <class MeshType>
 class coupledInfo
 {
-    // Reference to the parent mesh
-    const dynamicTopoFvMesh& mesh_;
 
-    // Auto pointer to a subMesh
-    autoPtr<dynamicTopoFvMesh> subMesh_;
+    // Private data
 
-    // Flag to determine whether maps have been built.
-    bool builtMaps_;
+        // Reference to the parent mesh
+        const MeshType& mesh_;
 
-    // For locally coupled patches,
-    // specify a master / slave index
-    coupleMap map_;
+        // Auto pointer to a subMesh
+        autoPtr<MeshType> subMesh_;
 
-    // Zone IDs for patches associated with faceZones
-    label masterFaceZone_;
-    label slaveFaceZone_;
+        // Flag to determine whether maps have been built.
+        bool builtMaps_;
 
-    //- Disallow default bitwise assignment
-    inline void operator=(const coupledInfo&);
+        // For locally coupled patches,
+        // specify a master / slave index
+        coupleMap map_;
+
+        // Zone IDs for patches associated with faceZones
+        label masterFaceZone_;
+        label slaveFaceZone_;
+
+    // Private member functions
+
+        // 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
-    );
+    //- Constructors
 
-    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
-    );
+        // Construct given mesh, coupleMap and master / slave indices
+        inline coupledInfo
+        (
+            const MeshType& mesh,
+            const coupleMap& cMap,
+            const label mfzIndex = -1,
+            const label sfzIndex = -1
+        );
+
+        // Construct from components
+        inline coupledInfo
+        (
+            const MeshType& 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;
+        inline const MeshType& baseMesh() const;
 
         // Set a new subMesh
-        inline void setMesh(label index, dynamicTopoFvMesh* mesh);
+        inline void setMesh(label index, MeshType* mesh);
 
         // Return a reference to the subMesh
-        inline dynamicTopoFvMesh& subMesh();
+        inline MeshType& subMesh();
 
         // Return a const reference to the subMesh
-        inline const dynamicTopoFvMesh& subMesh() const;
+        inline const MeshType& subMesh() const;
 
-        // Have maps been built?
+        // Return if maps have been built
         inline bool builtMaps() const;
 
-        // Change the flag
+        // Set internal state of maps as built
         inline void setBuiltMaps();
 
         // Return a reference to the coupleMap
@@ -128,8 +136,10 @@ public:
         // Return a const reference to the coupleMap
         inline const coupleMap& map() const;
 
-        // Return the master / slave face zone IDs
+        // Return the master face zone ID
         inline label masterFaceZone() const;
+
+        // Return the slave face zone ID
         inline label slaveFaceZone() const;
 
     //- Interpolation
@@ -179,7 +189,7 @@ public:
 
                 label sizeBeforeMapping() const
                 {
-                    return directAddressing_.size();
+                    return sizeBeforeMapping_;
                 }
 
                 bool direct() const
@@ -193,49 +203,34 @@ public:
                 }
         };
 
-        // Set subMesh centres
-        inline void setCentres(PtrList<volVectorField>& centres) const;
-
-        // Subset volume field
-        template <class Type>
-        tmp<GeometricField<Type, fvPatchField, volMesh> >
-        subSetVolField
+        // Subset geometric field
+        template <class GeomField, class ZeroType>
+        tmp<GeomField>
+        subSetField
         (
-            const GeometricField<Type, fvPatchField, volMesh>& field
+            const GeomField& f,
+            const ZeroType& zeroValue,
+            const labelList& internalMapper
         ) 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
+        // Subset geometric fields from registry to output stream
+        template <class GeomField, class ZeroType>
+        void send
         (
             const wordList& fieldNames,
             const word& fieldType,
+            const ZeroType& zeroValue,
+            const labelList& internalMapper,
             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
+        // Set geometric field pointers from input dictionary
         template <class GeomField>
         void setField
         (
             const wordList& fieldNames,
             const dictionary& fieldDicts,
+            const label internalSize,
             PtrList<GeomField>& fields
         ) const;
 
@@ -264,6 +259,14 @@ public:
             const List<labelListList>& boundaryReverseMaps,
             const List<PtrList<GeomField> >& srcFields
         );
+
+        // Resize boundaryFields for all fields in the registry
+        template <class GeomField>
+        static void resizeBoundaries
+        (
+            const objectRegistry& mesh,
+            const fvBoundaryMesh& boundary
+        );
 };
 
 } // End namespace Foam
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/dynamicTopoFvMeshCoupled.C
similarity index 86%
rename from src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
rename to src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/dynamicTopoFvMeshCoupled.C
index d5be28ff9..437179afc 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCoupled.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/dynamicTopoFvMeshCoupled.C
@@ -38,6 +38,7 @@ Author
 
 #include "Time.H"
 #include "eMesh.H"
+#include "Random.H"
 #include "triFace.H"
 #include "volFields.H"
 #include "changeMap.H"
@@ -64,6 +65,32 @@ namespace Foam
 
 defineTypeNameAndDebug(coupleMap, 0);
 
+//! \cond fileScope
+// Geometric relative match tolerance
+static scalar geomMatchTol_ = 1e-4;
+
+// Priority scheme enumerants
+enum priorityScheme
+{
+    LINEAR,
+    RANDOM,
+    LIST,
+    ROTATE,
+    MAX_PRIORITY_SCHEMES
+};
+
+// Priority scheme names
+static const char* prioritySchemeNames_[MAX_PRIORITY_SCHEMES + 1] =
+{
+    "Linear",
+    "Random",
+    "List",
+    "Rotate",
+    "Invalid"
+};
+
+//! \endcond
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Set coupled modification
@@ -101,7 +128,7 @@ void dynamicTopoFvMesh::initCoupledStack
             // Add only valid entities
             emptyEntity =
             (
-                twoDMesh_ ?
+                is2D() ?
                 faces_[eIter.key()].empty() :
                 edgeFaces_[eIter.key()].empty()
             );
@@ -128,7 +155,7 @@ void dynamicTopoFvMesh::initCoupledStack
                     stackElements[elemI] = stack(0)[elemI];
                 }
 
-                label elemType = twoDMesh_ ? 2 : 1;
+                label elemType = is2D() ? 2 : 1;
 
                 writeVTK
                 (
@@ -183,7 +210,7 @@ void dynamicTopoFvMesh::initCoupledStack
                 // Add this to the coupled modification stack.
                 if (addIndex)
                 {
-                    if (twoDMesh_)
+                    if (is2D())
                     {
                         stack(0).push(faceI);
                     }
@@ -202,53 +229,76 @@ void dynamicTopoFvMesh::initCoupledStack
         }
 
         // Check if this is a processor patch.
+        label myProcID = Pstream::myProcNo();
         label neiProcID = getNeighbourProcessor(pIndex);
 
-        if (neiProcID > -1)
+        // Check if this is a master processor patch.
+        if
+        (
+            neiProcID > -1
+         && priority(neiProcID, greaterOp<label>(), myProcID)
+        )
         {
-            // Check if this is a master processor patch.
-            if (neiProcID > Pstream::myProcNo())
+            // Add this to the coupled modification stack.
+            if (is2D())
             {
-                // Add this to the coupled modification stack.
-                if (twoDMesh_)
-                {
-                    stack(0).push(faceI);
-                }
-                else
-                {
-                    const label edgeEnum = coupleMap::EDGE;
-                    const labelList& mfEdges = faceEdges_[faceI];
+                stack(0).push(faceI);
+            }
+            else
+            {
+                const label edgeEnum = coupleMap::EDGE;
+                const label pointEnum = coupleMap::POINT;
 
-                    forAll(mfEdges, edgeI)
+                const labelList& mfEdges = faceEdges_[faceI];
+
+                forAll(mfEdges, edgeI)
+                {
+                    label eIndex = mfEdges[edgeI];
+
+                    const edge& checkEdge = edges_[eIndex];
+
+                    // Need to avoid this edge if it is
+                    // talking to higher-priority processors.
+                    bool permissible = true;
+
+                    forAll(procIndices_, pI)
                     {
-                        label eIndex = mfEdges[edgeI];
+                        label nProc = procIndices_[pI];
 
-                        // Need to avoid this edge if it is
-                        // talking to lower-ranked processors.
-                        bool permissible = true;
-
-                        forAll(procIndices_, pI)
+                        // List is specified in ascending order
+                        // of neighbour processors, so break out.
+                        if (priority(nProc, greaterOp<label>(), myProcID))
                         {
-                            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;
-                            }
+                            break;
                         }
 
-                        if (permissible)
+                        // Fetch reference to subMeshes
+                        const coupledMesh& recvMesh = recvMeshes_[pI];
+                        const coupleMap& rcMap = recvMesh.map();
+
+                        if (rcMap.findSlave(edgeEnum, eIndex) > -1)
                         {
-                            stack(0).push(eIndex);
+                            permissible = false;
+                            break;
                         }
+
+                        // Check points as well, since there might be
+                        // situations where both points lie on a lower
+                        // ranked processor, but not the edge itself.
+                        if
+                        (
+                            (rcMap.findSlave(pointEnum, checkEdge[0]) > -1)
+                         && (rcMap.findSlave(pointEnum, checkEdge[1]) > -1)
+                        )
+                        {
+                            permissible = false;
+                            break;
+                        }
+                    }
+
+                    if (permissible)
+                    {
+                        stack(0).push(eIndex);
                     }
                 }
             }
@@ -269,7 +319,7 @@ void dynamicTopoFvMesh::initCoupledStack
                 stackElements[elemI] = stack(0)[elemI];
             }
 
-            label elemType = twoDMesh_ ? 2 : 1;
+            label elemType = is2D() ? 2 : 1;
 
             writeVTK
             (
@@ -286,7 +336,7 @@ void dynamicTopoFvMesh::initCoupledStack
 // Execute load balancing operations on the mesh
 void dynamicTopoFvMesh::executeLoadBalancing
 (
-    const dictionary& balanceDict
+    dictionary& balanceDict
 )
 {
     if (!Pstream::parRun())
@@ -348,6 +398,10 @@ void dynamicTopoFvMesh::executeLoadBalancing
         }
     }
 
+    // Ensure that the number of processors is consistent,
+    // and silently modify dictionary entry if not
+    balanceDict.set("numberOfSubdomains", Pstream::nProcs());
+
     // Read decomposition options and initialize
     autoPtr<decompositionMethod> decomposerPtr
     (
@@ -366,8 +420,7 @@ void dynamicTopoFvMesh::executeLoadBalancing
         FatalErrorIn("void dynamicTopoFvMesh::executeLoadBalancing()")
             << "You have selected decomposition method "
             << decomposer.typeName
-            << " which is not parallel aware." << endl
-            << "Please select one that is (hierarchical, parMetis)"
+            << " which is not parallel aware."
             << exit(FatalError);
     }
 
@@ -493,23 +546,187 @@ void dynamicTopoFvMesh::executeLoadBalancing
     // 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();
+    procPriority_.clear();
     sendMeshes_.clear();
     recvMeshes_.clear();
 }
 
 
+// Set processor rank priority
+void dynamicTopoFvMesh::initProcessorPriority()
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    if (Pstream::master())
+    {
+        // Default to linear
+        int type = LINEAR;
+
+        const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+        if (meshSubDict.found("priorityScheme") || mandatory_)
+        {
+            word schemeType(meshSubDict.lookup("priorityScheme"));
+
+            type = MAX_PRIORITY_SCHEMES;
+
+            for (label i = 0; i < MAX_PRIORITY_SCHEMES; i++)
+            {
+                if (prioritySchemeNames_[i] == schemeType)
+                {
+                    type = i;
+                    break;
+                }
+            }
+        }
+
+        switch (type)
+        {
+            case LINEAR:
+            {
+                // Initialize to identity map
+                procPriority_ = identity(Pstream::nProcs());
+                break;
+            }
+
+            case RANDOM:
+            {
+                Random randomizer(std::time(NULL));
+
+                // Initialize to identity map
+                procPriority_ = identity(Pstream::nProcs());
+
+                for (label i = 0; i < Pstream::nProcs(); i++)
+                {
+                    // Specify a random index to shuffle
+                    label j = randomizer.integer(0, Pstream::nProcs() - 1);
+
+                    Foam::Swap(procPriority_[i], procPriority_[j]);
+                }
+
+                break;
+            }
+
+            case ROTATE:
+            {
+                const label listSize = Pstream::nProcs();
+
+                // Initialize to identity map
+                procPriority_ = identity(listSize);
+
+                // In-place reverse macro
+#               define inPlaceReverse(list)                                    \
+                {                                                              \
+                    const label listSize = list.size();                        \
+                    const label lastIndex = listSize - 1;                      \
+                    const label nIterations = listSize >> 1;                   \
+                                                                               \
+                    label elemI = 0;                                           \
+                    while (elemI < nIterations)                                \
+                    {                                                          \
+                        Swap(list[elemI], list[lastIndex - elemI]);            \
+                        elemI++;                                               \
+                    }                                                          \
+                }
+
+                // Rotate by time index
+                label n = time().timeIndex() % listSize;
+
+                if (n < 0)
+                {
+                    n += listSize;
+                }
+
+                // Rotate list in place
+                SubList<label> firstHalf(procPriority_, n, 0);
+                SubList<label> secondHalf(procPriority_, listSize - n, n);
+
+                inPlaceReverse(firstHalf);
+                inPlaceReverse(secondHalf);
+
+                inPlaceReverse(procPriority_);
+
+                break;
+            }
+
+            case LIST:
+            {
+                procPriority_ = labelList(meshSubDict.lookup("priorityList"));
+
+                if (procPriority_.size() != Pstream::nProcs())
+                {
+                    FatalErrorIn
+                    (
+                        "void dynamicTopoFvMesh::initProcessorPriority()"
+                    )
+                        << " Priority scheme size mismatch." << nl
+                        << "   List size: " << procPriority_.size() << nl
+                        << "   Processor count: " << Pstream::nProcs() << nl
+                        << abort(FatalError);
+                }
+
+                break;
+            }
+
+            default:
+            {
+                Info<< "Available schemes: " << endl;
+
+                for (label i = 0; i < MAX_PRIORITY_SCHEMES; i++)
+                {
+                    Info<< ' ' << prioritySchemeNames_[i] << endl;
+                }
+
+                FatalErrorIn
+                (
+                    "void dynamicTopoFvMesh::initProcessorPriority()"
+                )
+                    << " Unknown priority scheme." << nl
+                    << abort(FatalError);
+            }
+        }
+
+        // Send priority list to others
+        for (label proc = 1; proc < Pstream::nProcs(); proc++)
+        {
+            meshOps::pWrite(proc, procPriority_);
+        }
+    }
+    else
+    {
+        // Receive priority from master
+        procPriority_.setSize(Pstream::nProcs());
+        meshOps::pRead(Pstream::masterNo(), procPriority_);
+    }
+
+    // Wait for transfers to complete
+    meshOps::waitForBuffers();
+
+    if (debug)
+    {
+        labelList ranks(Pstream::nProcs(), -1);
+
+        forAll(ranks, procI)
+        {
+            ranks[procPriority_[procI]] = procI;
+        }
+
+        Info<< " Processor priority: " << procPriority_ << nl
+            << " Processor rankings: " << ranks
+            << endl;
+    }
+}
+
+
 // Identify coupled patches.
 //  - Also builds global shared point information.
 //  - Returns true if no coupled patches were found.
@@ -689,8 +906,6 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
     // 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)
@@ -710,6 +925,17 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
     // Shrink to actual size
     procIndices_.setSize(nTotalProcs);
 
+    // Initialize the processor priority list
+    initProcessorPriority();
+
+    // Sort by order of neighbouring
+    // processor priority - highest to lowest
+    Foam::sort
+    (
+        procIndices_,
+        UList<label>::less(procPriority_)
+    );
+
     // Size the PtrLists.
     sendMeshes_.setSize(nTotalProcs);
     recvMeshes_.setSize(nTotalProcs);
@@ -724,7 +950,8 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
         // specify an invalid patch ID for now
         label patchID = immNeighbours.found(proc) ? immNeighbours[proc] : -1;
 
-        if (proc < Pstream::myProcNo())
+        // Check if this processor is of higher priority
+        if (priority(proc, lessOp<label>(), Pstream::myProcNo()))
         {
             master = proc;
             slave = Pstream::myProcNo();
@@ -738,10 +965,10 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
         sendMeshes_.set
         (
             pI,
-            new coupledInfo
+            new coupledMesh
             (
                 *this,               // Reference to this mesh
-                twoDMesh_,           // 2D or 3D
+                is2D(),              // 2D or 3D
                 false,               // Not local
                 true,                // Sent to neighbour
                 patchID,             // Patch index
@@ -763,10 +990,10 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
         recvMeshes_.set
         (
             pI,
-            new coupledInfo
+            new coupledMesh
             (
                 *this,               // Reference to this mesh
-                twoDMesh_,           // 2D or 3D
+                is2D(),              // 2D or 3D
                 false,               // Not local
                 false,               // Not sent to neighbour
                 patchID,             // Patch index
@@ -796,44 +1023,20 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
         {
             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();
+            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());
-            }
+            writeVTK
+            (
+                "subMeshPoints_" +
+                Foam::name(Pstream::myProcNo()) + "to" +
+                Foam::name(proc),
+                cMap.subMeshPoints(),
+                0, false, true
+            );
 
             // Write out globalProcPoints as a VTK
-            const List<labelPair>& gpp = *gppPtr;
+            const List<labelPair>& gpp = cMap.globalProcPoints();
 
             if (gpp.size())
             {
@@ -850,7 +1053,7 @@ bool dynamicTopoFvMesh::identifyCoupledPatches()
                     Foam::name(Pstream::myProcNo()) + "to" +
                     Foam::name(proc),
                     gpPoints,
-                    0
+                    0, false, true
                 );
             }
         }
@@ -941,7 +1144,7 @@ void dynamicTopoFvMesh::readCoupledPatches()
                         IOobject::AUTO_WRITE,
                         true
                     ),
-                    twoDMesh_,
+                    is2D(),
                     true,
                     false,
                     mPatch,
@@ -953,7 +1156,7 @@ void dynamicTopoFvMesh::readCoupledPatches()
                 patchCoupling_.set
                 (
                     mPatch,
-                    new coupledInfo
+                    new coupledMesh
                     (
                         *this,
                         cMap,
@@ -1013,7 +1216,7 @@ void dynamicTopoFvMesh::readCoupledPatches()
                 IOobject::AUTO_WRITE,
                 true
             ),
-            twoDMesh_,
+            is2D(),
             true,
             false,
             patchI,
@@ -1025,7 +1228,7 @@ void dynamicTopoFvMesh::readCoupledPatches()
         patchCoupling_.set
         (
             patchI,
-            new coupledInfo(*this, cMap, -1, -1)
+            new coupledMesh(*this, cMap, -1, -1)
         );
     }
 }
@@ -1078,8 +1281,8 @@ void dynamicTopoFvMesh::moveCoupledSubMeshes()
     {
         label proc = procIndices_[pI];
 
-        const coupledInfo& sPM = sendMeshes_[pI];
-        const coupledInfo& rPM = recvMeshes_[pI];
+        const coupledMesh& sPM = sendMeshes_[pI];
+        const coupledMesh& rPM = recvMeshes_[pI];
 
         // Fetch the coupleMap
         const coupleMap& scMap = sPM.map();
@@ -1116,7 +1319,7 @@ void dynamicTopoFvMesh::moveCoupledSubMeshes()
     forAll(procIndices_, pI)
     {
         // Fetch non-const reference to patchSubMesh
-        coupledInfo& rPM = recvMeshes_[pI];
+        coupledMesh& rPM = recvMeshes_[pI];
 
         // Fetch the coupleMap
         const coupleMap& rcMap = rPM.map();
@@ -1143,9 +1346,9 @@ void dynamicTopoFvMesh::moveCoupledSubMeshes()
         mesh.resetPrimitives
         (
             xferCopy(rcMap.oldPointBuffer()),
-            Xfer<faceList>::null(),
-            Xfer<labelList>::null(),
-            Xfer<labelList>::null(),
+            (*reinterpret_cast<Xfer<faceList>*>(0)),
+            (*reinterpret_cast<Xfer<labelList>*>(0)),
+            (*reinterpret_cast<Xfer<labelList>*>(0)),
             patchSizes,
             patchStarts,
             false
@@ -1189,7 +1392,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
     // First check to ensure that this case can be handled
     forAll(procIndices_, pI)
     {
-        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+        const label cplEnum = is2D() ? coupleMap::FACE : coupleMap::EDGE;
 
         // Fetch reference to maps
         const coupleMap& cMap = recvMeshes_[pI].map();
@@ -1201,7 +1404,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         }
 
         // If this entity is being handled elsewhere, bail out
-        if (procIndices_[pI] < Pstream::myProcNo())
+        if (priority(procIndices_[pI], lessOp<label>(), Pstream::myProcNo()))
         {
             map.type() = -2;
 
@@ -1214,7 +1417,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
     // Agglomerate cells from surrounding subMeshes
     forAll(procIndices_, pI)
     {
-        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+        const label cplEnum = is2D() ? coupleMap::FACE : coupleMap::EDGE;
 
         // Fetch reference to maps
         const coupleMap& cMap = recvMeshes_[pI].map();
@@ -1230,7 +1433,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         // Fetch references
         Map<label>& procCellMap = cellsToInsert[pI];
 
-        if (twoDMesh_)
+        if (is2D())
         {
             // Insert the owner cell
             procCellMap.insert(mesh.owner_[sIndex], -1);
@@ -1312,8 +1515,10 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                 // Configure points which need to be inserted
                 forAll(sFace, pointI)
                 {
+                    label sFacePoint = sFace[pointI];
+
                     // Skip if added already
-                    if (pointsToInsert[pI].found(sFace[pointI]))
+                    if (pointsToInsert[pI].found(sFacePoint))
                     {
                         continue;
                     }
@@ -1321,11 +1526,11 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     // Check for coupled points
                     pointsToInsert[pI].insert
                     (
-                        sFace[pointI],
+                        sFacePoint,
                         cMap.findMaster
                         (
                             coupleMap::POINT,
-                            sFace[pointI]
+                            sFacePoint
                         )
                     );
                 }
@@ -1372,7 +1577,36 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     if (sePatch == -1)
                     {
                         // Slave edge was an interior one
-                        edgePatch = neiProcPatch;
+                        if (neiProcPatch > -1)
+                        {
+                            edgePatch = neiProcPatch;
+                        }
+                        else
+                        {
+                            neiProcNo = procIndices_[pI];
+
+                            if (debug > 3)
+                            {
+                                Pout<< nl << nl
+                                    << " No face contact with"
+                                    << " processor: " << neiProcNo
+                                    << endl;
+                            }
+
+                            label pIdx = sendMeshes_[pI].map().patchIndex();
+
+                            // Add a patch creation order, if necessary
+                            if (pIdx == -1 && !createPatch.found(neiProcNo))
+                            {
+                                createPatch.insert(neiProcNo, -1);
+                            }
+
+                            // Specify a value for edgePatch:
+                            //  - Specify a value that we can use
+                            //    to back out the patch after creation
+                            //  - Also needs to bypass failure check
+                            edgePatch = (-2 - neiProcNo);
+                        }
                     }
                     else
                     if (sePatch == (slaveBoundary.size() - 1))
@@ -1392,7 +1626,15 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                         {
                             // If this other processor is
                             // lesser-ranked, bail out.
-                            if (neiProcNo < Pstream::myProcNo())
+                            if
+                            (
+                                priority
+                                (
+                                    neiProcNo,
+                                    lessOp<label>(),
+                                    Pstream::myProcNo()
+                                )
+                            )
                             {
                                 map.type() = -2;
 
@@ -1448,9 +1690,13 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                         mesh.writeVTK("seEdge", seIndex, 1);
 
                         Pout<< " Could not find correct patch info: " << nl
+                            << " sEdge: " << sEdge << nl
                             << " seIndex: " << seIndex << nl
                             << " sePatch: " << sePatch << nl
                             << " neiProcPatch: " << neiProcPatch << nl
+                            << " neiProcNo: " << neiProcNo << nl
+                            << " proc: " << procIndices_[pI] << nl
+                            << " cMs: " << cMs << " cMe: " << cMe << nl
                             << " Patch Name: " <<
                             (
                                 sePatch > -1 ?
@@ -1480,7 +1726,36 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                 if (sfPatch == -1)
                 {
                     // Slave face was an interior one
-                    facePatch = neiProcPatch;
+                    if (neiProcPatch > -1)
+                    {
+                        facePatch = neiProcPatch;
+                    }
+                    else
+                    {
+                        neiProcNo = procIndices_[pI];
+
+                        if (debug > 3)
+                        {
+                            Pout<< nl << nl
+                                << " No face contact with"
+                                << " processor: " << neiProcNo
+                                << endl;
+                        }
+
+                        label pIdx = sendMeshes_[pI].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);
+                    }
                 }
                 else
                 if (sfPatch == (slaveBoundary.size() - 1))
@@ -1514,7 +1789,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                             {
                                 scalar dist = mag(fC - pts[ptI]);
 
-                                if (dist < (1e-4 * tol))
+                                if (dist < (geomMatchTol_ * tol))
                                 {
                                     // Face was converted before
                                     if (debug > 3)
@@ -1540,7 +1815,15 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     {
                         // If this other processor is
                         // lesser-ranked, bail out.
-                        if (neiProcNo < Pstream::myProcNo())
+                        if
+                        (
+                            priority
+                            (
+                                neiProcNo,
+                                lessOp<label>(),
+                                Pstream::myProcNo()
+                            )
+                        )
                         {
                             map.type() = -2;
 
@@ -1595,10 +1878,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                                     << abort(FatalError);
                             }
 
-                            label pIdx =
-                            (
-                                sendMeshes_[prI].map().patchIndex()
-                            );
+                            label pIdx = sendMeshes_[prI].map().patchIndex();
 
                             // Add a patch creation order, if necessary
                             if (pIdx == -1 && !createPatch.found(neiProcNo))
@@ -1655,12 +1935,213 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         }
     }
 
+    // Specify a merge tolerance for insertion points
+    scalar mergeTol =
+    (
+        is2D() ? 0.0 : geomMatchTol_ * magSqr(edges_[mIndex].vec(points_))
+    );
+
+    // Check for point / edge processor connections
+    if (is3D())
+    {
+        const label myProcNo = Pstream::myProcNo();
+
+        forAll(procIndices_, pI)
+        {
+            const Map<label>& cEdges = edgesToInsert[pI];
+            const coupleMap& cMap = recvMeshes_[pI].map();
+            const Map<labelList>& pEdgeMap = cMap.subMeshEdgeMap();
+            const Map<labelList>& pPointMap = cMap.subMeshPointMap();
+            const dynamicTopoFvMesh& sMesh = recvMeshes_[pI].subMesh();
+
+            // Some points may have been inserted by a prior
+            // operation involving disconnected entities.
+            // Check if points need to be truly inserted.
+            Map<label>& cPoints = pointsToInsert[pI];
+
+            forAllIter(Map<label>, cPoints, pIter)
+            {
+                if (pIter() > -1)
+                {
+                    continue;
+                }
+
+                label cSp = pIter.key();
+
+                Map<labelList>::const_iterator pIt = pPointMap.find(cSp);
+
+                if (pIt == pPointMap.end())
+                {
+                    continue;
+                }
+
+                const point& pointI = sMesh.points_[pIt.key()];
+
+                bool foundMaster = false;
+                const labelList& procs = pIt();
+
+                forAll(procs, procJ)
+                {
+                    label pJ = -1, nProcNo = procs[procJ];
+
+                    if
+                    (
+                        (nProcNo == procIndices_[pI]) ||
+                        ((pJ = findIndex(procIndices_, nProcNo)) == -1)
+                    )
+                    {
+                        continue;
+                    }
+
+                    // Fetch map from the other processor,
+                    // and check if a mapping already exists
+                    const coupleMap& cMapJ = recvMeshes_[pJ].map();
+                    const Map<labelList>& pMapJ = cMapJ.subMeshPointMap();
+                    const dynamicTopoFvMesh& sMeshJ = recvMeshes_[pJ].subMesh();
+
+                    forAllConstIter(Map<labelList>, pMapJ, pjIter)
+                    {
+                        label pointMaster =
+                        (
+                            cMapJ.findMaster
+                            (
+                                coupleMap::POINT,
+                                pjIter.key()
+                            )
+                        );
+
+                        if (pointMaster == -1)
+                        {
+                            continue;
+                        }
+
+                        const point& pointJ = sMeshJ.points_[pjIter.key()];
+
+                        if (magSqr(pointI - pointJ) < mergeTol)
+                        {
+                            if (debug > 2)
+                            {
+                                Pout<< " Using mapped point: " << pjIter.key()
+                                    << " :: " << pointJ
+                                    << " procs: " << pjIter()
+                                    << " master: " << pointMaster
+                                    << endl;
+                            }
+
+                            // Assign to existing master point
+                            pIter() = pointMaster;
+
+                            // Update maps for the point
+                            cMap.mapSlave
+                            (
+                                coupleMap::POINT,
+                                pIter(), pIter.key()
+                            );
+
+                            cMap.mapMaster
+                            (
+                                coupleMap::POINT,
+                                pIter.key(), pIter()
+                            );
+
+                            foundMaster = true;
+                            break;
+                        }
+                    }
+
+                    if (foundMaster)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            forAllConstIter(Map<label>, cEdges, eIter)
+            {
+                label cSe = eIter.key();
+
+                Map<labelList>::const_iterator eIt = pEdgeMap.find(cSe);
+
+                if (eIt != pEdgeMap.end())
+                {
+                    const labelList& procs = eIt();
+
+                    forAll(procs, procI)
+                    {
+                        label nProcNo = procs[procI];
+
+                        if (priority(nProcNo, greaterEqOp<label>(), myProcNo))
+                        {
+                            continue;
+                        }
+
+                        if (debug > 3)
+                        {
+                            Pout<< nl << nl
+                                << " Edge: " << cSe
+                                << " :: " << sMesh.edges_[cSe]
+                                << " is talking to processors: " << procs
+                                << " so bailing out."
+                                << endl;
+                        }
+
+                        map.type() = -2;
+
+                        return map;
+                    }
+                }
+
+                const edge& checkEdge = sMesh.edges_[cSe];
+
+                forAll(checkEdge, pointI)
+                {
+                    label cSp = checkEdge[pointI];
+
+                    Map<labelList>::const_iterator pIt = pPointMap.find(cSp);
+
+                    if (pIt == pPointMap.end())
+                    {
+                        continue;
+                    }
+
+                    const labelList& procs = pIt();
+
+                    forAll(procs, procI)
+                    {
+                        label nProcNo = procs[procI];
+
+                        if (priority(nProcNo, greaterEqOp<label>(), myProcNo))
+                        {
+                            continue;
+                        }
+
+                        if (debug > 3)
+                        {
+                            Pout<< nl << nl
+                                << " Points: " << nl
+                                << "  Edge[0]: " << checkEdge[0] << nl
+                                << "  Edge[1]: " << checkEdge[1] << nl
+                                << " Processor conflict: " << nl
+                                << "  Point: " << cSp << nl
+                                << "  Processors: " << procs
+                                << endl;
+                        }
+
+                        map.type() = -2;
+
+                        return map;
+                    }
+                }
+            }
+        }
+    }
+
     // Perform a few debug calls before modifications
     if (debug > 1)
     {
         Pout<< nl << nl
             << "Inserting cell(s) around coupled "
-            << (twoDMesh_ ? "face: " : "edge: ") << mIndex
+            << (is2D() ? "face: " : "edge: ") << mIndex
             << endl;
     }
 
@@ -1673,6 +2154,28 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         // Create a new processor patch
         procIter() = createProcessorPatch(neiProcNo);
 
+        // Renumber edge conversion patches
+        forAll(masterConvertEdgePatch, pI)
+        {
+            Map<label>& convertMap = masterConvertEdgePatch[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();
+                    }
+                }
+            }
+        }
+
+        // Renumber face conversion patches
         forAll(masterConvertFacePatch, pI)
         {
             Map<label>& convertMap = masterConvertFacePatch[pI];
@@ -1706,13 +2209,13 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         // Create patch on subMesh
         dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
 
-        mesh.createProcessorPatch(Pstream::myProcNo());
+        slaveConvertPatch[pI] = mesh.createProcessorPatch(Pstream::myProcNo());
     }
 
     // Build a list of mapping entities on this processor
     DynamicList<label> mapCells(10);
 
-    if (twoDMesh_)
+    if (is2D())
     {
         label own = owner_[mIndex];
 
@@ -1746,7 +2249,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
     // create an equivalent on this mesh
     forAll(procIndices_, pI)
     {
-        const label cplEnum = twoDMesh_ ? coupleMap::FACE : coupleMap::EDGE;
+        const label cplEnum = is2D() ? coupleMap::FACE : coupleMap::EDGE;
 
         // Fetch reference to maps
         const coupleMap& cMap = recvMeshes_[pI].map();
@@ -1850,13 +2353,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         }
     }
 
-    // Loop through all insertion points, and merge if necessary
-    scalar mergeTol =
-    (
-        twoDMesh_ ? 0.0 : 1e-4 * mag(edges_[mIndex].vec(points_))
-    );
-
-    // Insert all points
+    // Insert all points, with merging if necessary
     forAll(pointsToInsert, pI)
     {
         Map<label>& procPointMapI = pointsToInsert[pI];
@@ -1894,7 +2391,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                 {
                     const point& pointJ = meshJ.points_[pItJ.key()];
 
-                    if (mag(pointI - pointJ) < mergeTol)
+                    if (magSqr(pointI - pointJ) < mergeTol)
                     {
                         if (pItJ() == -1)
                         {
@@ -2025,7 +2522,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
 
     // Occassionally, inserted edges may already be present.
     // Ensure that edges are not added twice.
-    if (!twoDMesh_)
+    if (is3D())
     {
         forAll(facesToInsert, pI)
         {
@@ -2110,7 +2607,15 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                             }
 
                             edgesToInsert[pI][seIndex] = meIndex;
-                            edgesToConvert[pI][seIndex] = meIndex;
+
+                            if (edgesToConvert[pI].found(seIndex))
+                            {
+                                edgesToConvert[pI][seIndex] = meIndex;
+                            }
+                            else
+                            {
+                                edgesToConvert[pI].insert(seIndex, meIndex);
+                            }
                         }
                     }
                 }
@@ -2370,7 +2875,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                             if
                             (
                                 convertPatchPoints[pI].found(fJ.key())
-                             &&	convertPatchPoints[pJ].found(fI.key())
+                             && convertPatchPoints[pJ].found(fI.key())
                             )
                             {
                                 convertPatchPoints[pI].erase(fJ.key());
@@ -2383,6 +2888,11 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                         break;
                     }
                 }
+
+                if (foundDuplicate)
+                {
+                    break;
+                }
             }
 
             // Face was inserted before, so don't insert again
@@ -2504,13 +3014,11 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     nPatch,
                     nF,
                     nOwner,
-                    nNeighbour
+                    nNeighbour,
+                    nFaceEdges
                 )
             );
 
-            // Add the faceEdges entry as well
-            faceEdges_.append(nFaceEdges);
-
             // Size up edgeFaces for each edge
             forAll(nFaceEdges, edgeI)
             {
@@ -2577,8 +3085,10 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
             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.
+            //  - Orientation should be correct, because this is a boundary
+            //    face converted to an interior, and adjacent to an added cell.
+            //  - Add the new faceEdges from the existing face. This may contain
+            //    edges that need to be converted, but that will be done later.
             label newFaceIndex =
             (
                 insertFace
@@ -2586,14 +3096,11 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     -1,
                     face(faces_[fIndex]),
                     mFaceOwn,
-                    newNeighbour
+                    newNeighbour,
+                    labelList(faceEdges_[fIndex])
                 )
             );
 
-            // 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));
 
@@ -2632,7 +3139,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
 
             // For 2D meshes, the boundary face gets converted
             // to an interior one. Note the index for further operations.
-            if ((mIndex == fIndex) && twoDMesh_)
+            if ((mIndex == fIndex) && is2D())
             {
                 map.index() = newFaceIndex;
             }
@@ -2721,7 +3228,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                 scalar tol = mag(mesh.points_[fCheck[0]] - fC);
                 scalar dist = mag(fC - newCentre);
 
-                if (dist < (1e-4 * tol))
+                if (dist < (geomMatchTol_ * tol))
                 {
                     replaceFace = faceI;
                     break;
@@ -2763,6 +3270,8 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
             // Obtain a copy before adding the new face,
             // since the reference might become
             // invalid during list resizing.
+            // Edges don't have to change, since they're
+            // all on the boundary anyway.
             face newFace = mesh.faces_[replaceFace];
             label newOwn = mesh.owner_[replaceFace];
             labelList newFaceEdges = mesh.faceEdges_[replaceFace];
@@ -2774,15 +3283,11 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     procPatch,
                     newFace,
                     newOwn,
-                    -1
+                    -1,
+                    newFaceEdges
                 )
             );
 
-            // 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
 
@@ -2931,7 +3436,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     keepEdge = false;
                 }
                 else
-                if ((mIndex == eIndex) && !twoDMesh_ && map.index() == -1)
+                if ((mIndex == eIndex) && is3D() && map.index() == -1)
                 {
                     // Keep the edge, and note index for later
                     keepEdge = true;
@@ -2979,7 +3484,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
 
             // For 3D meshes, the boundary edge gets converted
             // to an interior one. Note the index for further operations.
-            if ((mIndex == eIndex) && !twoDMesh_)
+            if ((mIndex == eIndex) && is3D())
             {
                 map.index() = newEdgeIndex;
             }
@@ -2992,6 +3497,8 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
     List<changeMap> slaveMaps(procIndices_.size());
 
     // Loop through all processors, and remove cells
+    const label emptyMap = -7;
+
     forAll(cellsToInsert, pI)
     {
         const Map<label>& procCellMap = cellsToInsert[pI];
@@ -2999,7 +3506,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         if (procCellMap.empty())
         {
             // Set type to something recognizable
-            slaveMaps[pI].type() = -7;
+            slaveMaps[pI].type() = emptyMap;
 
             continue;
         }
@@ -3028,7 +3535,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         const changeMap& slaveMap = slaveMaps[pI];
 
         // Skip empty entities
-        if (slaveMap.type() == -7)
+        if (slaveMap.type() == emptyMap)
         {
             continue;
         }
@@ -3163,7 +3670,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
         }
 
         // Map edges for 3D meshes
-        if (!twoDMesh_)
+        if (is3D())
         {
             // Map edges from patches.
             const Map<label>& procEdgeMap = edgesToInsert[pI];
@@ -3376,7 +3883,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     continue;
                 }
 
-                if (twoDMesh_)
+                if (is2D())
                 {
                     if (face::compare(cFace, sFace))
                     {
@@ -3438,7 +3945,7 @@ const changeMap dynamicTopoFvMesh::insertCells(const label mIndex)
                     << abort(FatalError);
             }
 
-            if (twoDMesh_)
+            if (is2D())
             {
                 continue;
             }
@@ -3598,7 +4105,7 @@ const changeMap dynamicTopoFvMesh::removeCells
                 edgesToConvert.set(fEdges[edgeI], -1);
             }
 
-            if (twoDMesh_)
+            if (is2D())
             {
                 // Add all points as candidates for removal.
                 // Some (or all) of these will be weeded out.
@@ -3660,7 +4167,7 @@ const changeMap dynamicTopoFvMesh::removeCells
     }
 
     // Build a set of points to be removed.
-    if (twoDMesh_)
+    if (is2D())
     {
         forAllConstIter(Map<label>, edgesToConvert, eIter)
         {
@@ -3834,6 +4341,7 @@ const changeMap dynamicTopoFvMesh::removeCells
         }
 
         // Insert the reconfigured face at the boundary.
+        // faceEdges will be corrected later.
         fIter() =
         (
             insertFace
@@ -3841,14 +4349,11 @@ const changeMap dynamicTopoFvMesh::removeCells
                 patch,
                 newFace,
                 newOwner,
-                -1
+                -1,
+                fEdges
             )
         );
 
-        // Add the faceEdges entry.
-        // Edges will be corrected later.
-        faceEdges_.append(fEdges);
-
         // Add this face to the map.
         map.addFace(fIter());
 
@@ -4190,7 +4695,7 @@ void dynamicTopoFvMesh::handleCoupledPatches
         initCoupledStack(entities, false);
     }
 
-    if (twoDMesh_)
+    if (is2D())
     {
         swap2DEdges(&(handlerPtr_[0]));
     }
@@ -4243,25 +4748,29 @@ void dynamicTopoFvMesh::handleCoupledPatches
     {
         label proc = procIndices_[pI];
 
-        coupledInfo& sPM = sendMeshes_[pI];
-        coupledInfo& rPM = recvMeshes_[pI];
+        coupledMesh& sPM = sendMeshes_[pI];
+        coupledMesh& rPM = recvMeshes_[pI];
 
-        if (proc < Pstream::myProcNo())
+        if (priority(proc, lessOp<label>(), Pstream::myProcNo()))
         {
             const coupleMap& cMap = sPM.map();
 
             // How many entities am I receiving..
-            label nEntities = -1, nMovePoints = -1;
+            FixedList<label, 3> nOps(-1);
 
-            meshOps::pRead(proc, nEntities);
-            meshOps::pRead(proc, nMovePoints);
+            meshOps::pRead(proc, nOps);
+
+            label nEntities = nOps[0];
+            label nMovePoints = nOps[1];
+            label nPatchConvert = nOps[2];
 
             if (debug > 3)
             {
-                Pout<< " Op tranfer:"
+                Pout<< " Op transfer:"
                     << " Receiving from [" << proc << "]::"
                     << " nEntities: " << nEntities
                     << " nMovePoints: " << nMovePoints
+                    << " nPatchConvert: " << nPatchConvert
                     << endl;
             }
 
@@ -4292,17 +4801,31 @@ void dynamicTopoFvMesh::handleCoupledPatches
                 meshOps::pRead(proc, newPoints);
                 meshOps::pRead(proc, oldPoints);
             }
+
+            if (nPatchConvert)
+            {
+                // Size up the receipt buffers
+                labelList& patches = cMap.patchIndices();
+
+                patches.setSize(nPatchConvert);
+
+                // Schedule patch indices for receipt
+                meshOps::pRead(proc, patches);
+            }
         }
         else
         {
             const coupleMap& cMap = rPM.map();
 
+            FixedList<label, 3> nOps(-1);
+
             label nEntities = cMap.entityIndices().size();
             label nMovePoints = cMap.moveNewPoints().size();
+            label nPatchConvert = cMap.patchIndices().size();
 
             if (debug > 3)
             {
-                Pout<< " Op tranfer:"
+                Pout<< " Op transfer:"
                     << " Sending to [" << proc << "]:: "
                     << " nEntities: " << nEntities << nl
                     << "  entityIndices: " << cMap.entityIndices() << nl
@@ -4310,11 +4833,16 @@ void dynamicTopoFvMesh::handleCoupledPatches
                     << " nMovePoints: " << nMovePoints << nl
                     << "  moveNewPoints: " << cMap.moveNewPoints() << nl
                     << "  moveOldPoints: " << cMap.moveOldPoints() << nl
+                    << " nPatchConvert: " << nPatchConvert << nl
+                    << "  patchIndices: " << cMap.patchIndices() << nl
                     << endl;
             }
 
-            meshOps::pWrite(proc, nEntities);
-            meshOps::pWrite(proc, nMovePoints);
+            nOps[0] = nEntities;
+            nOps[1] = nMovePoints;
+            nOps[2] = nPatchConvert;
+
+            meshOps::pWrite(proc, nOps);
 
             if (nEntities)
             {
@@ -4329,6 +4857,12 @@ void dynamicTopoFvMesh::handleCoupledPatches
                 meshOps::pWrite(proc, cMap.moveNewPoints());
                 meshOps::pWrite(proc, cMap.moveOldPoints());
             }
+
+            if (nPatchConvert)
+            {
+                // Schedule transfer to processor
+                meshOps::pWrite(proc, cMap.patchIndices());
+            }
         }
     }
 
@@ -4346,44 +4880,54 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
         return;
     }
 
+    // Temporarily reset maxModifications to
+    // ensure that synchronization succeeds
+    label maxModSave = maxModifications_;
+
+    maxModifications_ = -1;
+
     const polyBoundaryMesh& boundary = boundaryMesh();
 
-    labelList createPatchOrders(Pstream::nProcs(), 0);
+    labelList createPatchOrders(procIndices_.size(), 0);
 
     forAll(procIndices_, pI)
     {
-        const coupleMap& cMap = sendMeshes_[pI].map();
+        const coupleMap& cMap = recvMeshes_[pI].map();
 
         if (cMap.patchIndex() >= boundary.size())
         {
             // This processor needs a new patch talking to me
-            createPatchOrders[procIndices_[pI]] = 1;
+            createPatchOrders[pI] = 1;
         }
     }
 
     // Send / recv create patch orders, if any
-    for (label proc = 0; proc < Pstream::nProcs(); proc++)
+    forAll(procIndices_, pI)
     {
-        if (proc == Pstream::myProcNo())
-        {
-            continue;
-        }
+        label proc = procIndices_[pI];
 
-        if (proc > Pstream::myProcNo())
+        if (priority(proc, greaterOp<label>(), Pstream::myProcNo()))
         {
-            meshOps::pWrite(proc, createPatchOrders[proc]);
+            // Non-blocking send to processor
+            meshOps::pWrite(proc, createPatchOrders[pI], false);
         }
         else
         {
-            meshOps::pRead(proc, createPatchOrders[proc]);
+            // Non-blocking receive from processor
+            meshOps::pRead(proc, createPatchOrders[pI], false);
         }
     }
 
+    // Wait for all transfers to complete.
+    meshOps::waitForBuffers();
+
     Map<label> addedProcPatches;
 
-    for (label proc = 0; proc < Pstream::myProcNo(); proc++)
+    forAll(procIndices_, pI)
     {
-        if (createPatchOrders[proc])
+        label proc = procIndices_[pI];
+
+        if (createPatchOrders[pI])
         {
             // Create a new processor patch
             addedProcPatches.insert
@@ -4394,9 +4938,6 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
         }
     }
 
-    // Wait for all transfers to complete.
-    meshOps::waitForBuffers();
-
     // Buffer for cell-removal
     DynamicList<label> rCellList(10);
 
@@ -4404,13 +4945,15 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
     {
         label proc = procIndices_[pI];
 
-        const coupledInfo& sPM = sendMeshes_[pI];
+        const coupledMesh& sPM = sendMeshes_[pI];
 
-        if (proc < Pstream::myProcNo())
+        if (priority(proc, lessOp<label>(), Pstream::myProcNo()))
         {
             const coupleMap& cMap = sPM.map();
             const labelList& indices = cMap.entityIndices();
             const List<coupleMap::opType>& operations = cMap.entityOperations();
+
+            const labelList& patches = cMap.patchIndices();
             const pointField& newPoints = cMap.moveNewPoints();
             const pointField& oldPoints = cMap.moveOldPoints();
 
@@ -4447,11 +4990,33 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                 else
                 if (operations.size())
                 {
+                    bool required = false;
+
+                    forAll(operations, opI)
+                    {
+                        const coupleMap::opType op = operations[opI];
+
+                        if
+                        (
+                            op == coupleMap::REMOVE_CELL ||
+                            op == coupleMap::CONVERT_PATCH
+                        )
+                        {
+                            required = true;
+                            break;
+                        }
+                    }
+
                     // 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);
+                    // this processor that require patch conversion,
+                    // this is a problem.
+                    if (required)
+                    {
+                        Pout<< " * * * Sync Operations * * * " << nl
+                            << " Could not find patch for proc: " << proc << nl
+                            << " procIndices: " << procIndices_
+                            << abort(FatalError);
+                    }
                 }
                 else
                 {
@@ -4460,7 +5025,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                 }
             }
 
-            label pointCounter = 0;
+            label pointCounter = 0, patchCounter = 0;
 
             // Sequentially execute operations
             forAll(indices, indexI)
@@ -4481,7 +5046,11 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                     localIndex = cMap.entityMap(coupleMap::POINT)[index];
                 }
                 else
-                if (op == coupleMap::CONVERT_PATCH)
+                if
+                (
+                    op == coupleMap::CONVERT_PATCH ||
+                    op == coupleMap::CONVERT_PHYSICAL
+                )
                 {
                     localIndex =
                     (
@@ -4491,20 +5060,31 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
 
                     if (debug > 3)
                     {
-                        const point& newCentre = newPoints[pointCounter];
-                        const point& oldCentre = oldPoints[pointCounter];
+                        if (op == coupleMap::CONVERT_PATCH)
+                        {
+                            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;
+                            Pout<< " Convert patch: " << index << nl
+                                << "  localIndex: " << localIndex << nl
+                                << "  newCentre: " << newCentre << nl
+                                << "  oldCentre: " << oldCentre << nl
+                                << endl;
+                        }
+
+                        if (op == coupleMap::CONVERT_PHYSICAL)
+                        {
+                            Pout<< " Convert patch: " << index << nl
+                                << "  localIndex: " << localIndex << nl
+                                << "  patch: " << patches[patchCounter] << nl
+                                << endl;
+                        }
                     }
                 }
                 else
                 {
                     // Pick localIndex based on entity type
-                    if (twoDMesh_)
+                    if (is2D())
                     {
                         const Map<label>& fM = cMap.entityMap(coupleMap::FACE);
 
@@ -4581,7 +5161,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                         // Clear existing list
                         rCellList.clear();
 
-                        if (twoDMesh_)
+                        if (is2D())
                         {
                             // Insert the owner cell
                             rCellList.append(owner_[localIndex]);
@@ -4690,7 +5270,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                                 scalar tol = mag(points_[fCheck[0]] - fC);
                                 scalar dist = mag(fC - newCentre);
 
-                                if (dist < (1e-4 * tol))
+                                if (dist < (geomMatchTol_ * tol))
                                 {
                                     localIndex = faceI;
                                     break;
@@ -4740,7 +5320,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                         scalar dist = mag(fC - newCentre);
 
                         // Ensure a face-match
-                        if (dist > (1e-4 * tol))
+                        if (dist > (geomMatchTol_ * tol))
                         {
                             Pout<< " * * * Sync Operations * * * " << nl
                                 << " Convert patch Op failed." << nl
@@ -4750,7 +5330,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                                 << " faceCentre: " << fC << nl
                                 << " Master processor: " << proc << nl
                                 << " procPatch: " << procPatch << nl
-                                << " tolerance: " << tol << nl
+                                << " tolerance: " << (geomMatchTol_ * tol) << nl
                                 << " distance: " << dist << nl
                                 << " pointCounter: " << pointCounter << nl
                                 << " newCentre: " << newCentre << nl
@@ -4761,6 +5341,8 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                         // Obtain a copy before adding the new face,
                         // since the reference might become
                         // invalid during list resizing.
+                        // Edges don't have to change, since they're
+                        // all on the boundary anyway.
                         face newFace = faces_[localIndex];
                         label newOwn = owner_[localIndex];
                         labelList newFaceEdges = faceEdges_[localIndex];
@@ -4772,15 +5354,11 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                                 procPatch,
                                 newFace,
                                 newOwn,
-                                -1
+                                -1,
+                                newFaceEdges
                             )
                         );
 
-                        // 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,
@@ -4820,6 +5398,70 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
                         break;
                     }
 
+                    case coupleMap::CONVERT_PHYSICAL:
+                    {
+                        const label patchIndex = patches[patchCounter];
+
+                        // Obtain a copy before adding the new face,
+                        // since the reference might become
+                        // invalid during list resizing.
+                        // Edges don't have to change, since they're
+                        // all on the boundary anyway.
+                        face newFace = faces_[localIndex];
+                        label newOwn = owner_[localIndex];
+                        labelList newFaceEdges = faceEdges_[localIndex];
+
+                        label newFaceIndex =
+                        (
+                            insertFace
+                            (
+                                patchIndex,
+                                newFace,
+                                newOwn,
+                                -1,
+                                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;
+
+                        patchCounter++;
+
+                        break;
+                    }
+
                     case coupleMap::INVALID:
                     {
                         Pout<< " * * * Sync Operations * * * " << nl
@@ -4847,6 +5489,9 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
         }
     }
 
+    // Reinstate max modifications
+    maxModifications_ = maxModSave;
+
     // Re-Initialize the stack with avoided entities from subMeshes
     // and leave those on processor patches untouched
     labelHashSet procEntities;
@@ -4874,7 +5519,7 @@ void dynamicTopoFvMesh::syncCoupledPatches(labelHashSet& entities)
     // Re-Initialize the stack, using supplied entities
     initCoupledStack(entities, true);
 
-    if (twoDMesh_)
+    if (is2D())
     {
         swap2DEdges(&(handlerPtr_[0]));
     }
@@ -4893,9 +5538,6 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
 
     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());
@@ -5013,7 +5655,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                         (
                             Foam::transform
                             (
-                                cp.transformT(0),
+                                cp.forwardT()[0],
                                 half0Centres[faceI]
                             )
                         );
@@ -5022,7 +5664,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                         (
                             Foam::transform
                             (
-                                cp.transformT(0),
+                                cp.forwardT()[0],
                                 mAnchors[pI][faceI]
                             )
                         );
@@ -5053,7 +5695,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                     scalar rMagSf = mag(half1Areas[faceI]);
                     scalar avSf = 0.5 * (fMagSf + rMagSf);
 
-                    if (mag(fMagSf - rMagSf)/avSf > gTol)
+                    if (mag(fMagSf - rMagSf)/avSf > geomMatchTol_)
                     {
                         misMatchError = true;
 
@@ -5071,7 +5713,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                         Foam::max
                         (
                             pTol,
-                            gTol * mag(lP[lF[faceI][0]] - lC[faceI])
+                            geomMatchTol_ * mag(lP[lF[faceI][0]] - lC[faceI])
                         )
                     );
                 }
@@ -5217,7 +5859,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
             scalar nbrMagSf = mag(fAreas[pI][faceI]);
             scalar avSf = 0.5 * (magSf + nbrMagSf);
 
-            if (mag(magSf - nbrMagSf)/avSf > gTol)
+            if (mag(magSf - nbrMagSf)/avSf > geomMatchTol_)
             {
                 misMatchError = true;
 
@@ -5236,7 +5878,7 @@ bool dynamicTopoFvMesh::checkCoupledBoundaries(bool report) const
                 Foam::max
                 (
                     pTol,
-                    gTol *
+                    geomMatchTol_ *
                     mag
                     (
                         myPoints[myFaces[faceI][0]]
@@ -5327,7 +5969,7 @@ void dynamicTopoFvMesh::buildProcessorPatchMeshes()
     {
         label proc = procIndices_[pI];
 
-        coupledInfo& sPM = sendMeshes_[pI];
+        coupledMesh& sPM = sendMeshes_[pI];
 
         // Build the subMesh.
         buildProcessorPatchMesh(sPM, commonCells);
@@ -5357,7 +5999,7 @@ void dynamicTopoFvMesh::buildProcessorPatchMeshes()
         }
 
         // Obtain references
-        const coupledInfo& rPM = recvMeshes_[pI];
+        const coupledMesh& rPM = recvMeshes_[pI];
         const coupleMap& rcMap = rPM.map();
 
         // First read entity sizes.
@@ -5396,7 +6038,7 @@ void dynamicTopoFvMesh::buildProcessorPatchMeshes()
 //   of neighbouring processors.
 void dynamicTopoFvMesh::buildProcessorPatchMesh
 (
-    coupledInfo& subMesh,
+    coupledMesh& subMesh,
     Map<labelList>& commonCells
 )
 {
@@ -5432,30 +6074,6 @@ void dynamicTopoFvMesh::buildProcessorPatchMesh
     // Check if this is a direct neighbour
     const polyBoundaryMesh& boundary = boundaryMesh();
 
-/*
-    // unused code section - to be removed
-    // HR: 30/11/2013
-
-    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)
@@ -5489,13 +6107,19 @@ void dynamicTopoFvMesh::buildProcessorPatchMesh
     labelHashSet localCommonCells;
 
     // Detect all cells surrounding shared points.
-    if (twoDMesh_)
+    if (is2D())
     {
         // No pointEdges structure, so loop through all cells
         // to check for those connected to subMeshPoints
         forAll(cells_, cellI)
         {
             const cell& cellToCheck = cells_[cellI];
+
+            if (cellToCheck.empty())
+            {
+                continue;
+            }
+
             const labelList cellPoints = cellToCheck.labels(faces_);
 
             forAll(cellPoints, pointI)
@@ -5927,15 +6551,12 @@ void dynamicTopoFvMesh::buildProcessorPatchMesh
         }
     }
 
-    // Fill variable size face-list sizes for 2D
-    if (twoDMesh_)
-    {
-        labelList& nfeBuffer = cMap.entityBuffer(coupleMap::NFE_BUFFER);
+    // Fill variable size face-list sizes
+    labelList& nfeBuffer = cMap.entityBuffer(coupleMap::NFE_BUFFER);
 
-        forAllConstIter(Map<label>, faceMap, fIter)
-        {
-            nfeBuffer[fIter.key()] = faces_[fIter()].size();
-        }
+    forAllConstIter(Map<label>, faceMap, fIter)
+    {
+        nfeBuffer[fIter.key()] = faces_[fIter()].size();
     }
 
     // Fill in boundary information
@@ -6013,7 +6634,7 @@ void dynamicTopoFvMesh::buildProcessorPatchMesh
             );
 
             // Add type
-            patchSubDict.add("type", "processor");
+            patchSubDict.add("type", "subMeshProcessor");
 
             // Add start / size
             patchSubDict.add("startFace", bdyFaceStarts[patchI]);
@@ -6116,10 +6737,9 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
 
     // 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();
+    scalar tol = geomMatchTol_ * box.mag();
 
     const polyBoundaryMesh& boundary = boundaryMesh();
 
@@ -6181,7 +6801,7 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
                 FatalErrorIn("void dynamicTopoFvMesh::buildLocalCoupledMaps()")
                     << " Failed to match all points"
                     << " within a tolerance of: " << tol << nl
-                    << " relTol: " << relTol << nl
+                    << " matchTol: " << geomMatchTol_ << nl
                     << abort(FatalError);
             }
 
@@ -6247,7 +6867,7 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
 
                 const face& mFace = faces_[mfIndex];
 
-                if (twoDMesh_)
+                if (is2D())
                 {
                     // Set up a comparison face.
                     face cFace(4);
@@ -6504,7 +7124,7 @@ void dynamicTopoFvMesh::buildLocalCoupledMaps()
                 );
             }
 
-            if (twoDMesh_)
+            if (is2D())
             {
                 continue;
             }
@@ -6598,7 +7218,7 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
     {
         label proc = procIndices_[pI];
 
-        coupledInfo& rPM = recvMeshes_[pI];
+        coupledMesh& rPM = recvMeshes_[pI];
         const coupleMap& cMap = rPM.map();
         const labelList& ptBuffer = cMap.entityBuffer(coupleMap::PATCH_ID);
 
@@ -6649,7 +7269,7 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
                 );
 
                 // Add type
-                patchSubDict.add("type", "processor");
+                patchSubDict.add("type", "subMeshProcessor");
 
                 // Add start / size
                 patchSubDict.add("startFace", faceStarts[patchI]);
@@ -6716,7 +7336,8 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
               + Foam::name(Pstream::myProcNo())
               + "to"
               + Foam::name(proc),
-                identity(cMap.nEntities(coupleMap::CELL))
+                identity(cMap.nEntities(coupleMap::CELL)),
+                3, false, true
             );
         }
 
@@ -6842,11 +7463,8 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
             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();
+            scalar tol = geomMatchTol_ * box.mag();
 
             forAllConstIter(Map<label>, pMap, pIter)
             {
@@ -6875,9 +7493,6 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
         // 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();
@@ -6889,10 +7504,11 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
             const Map<label>& fMap = cMap.entityMap(coupleMap::FACE);
 
             // Fetch global pointFaces for the slave.
-            const labelListList& spF = rPM.subMesh().pointFaces();
+            const faceList& slaveFaces = sMesh.faces();
+            const labelListList& spF = sMesh.pointFaces();
 
             // Match patch faces for both 2D and 3D.
-            for(label i = 0; i < mSize; i++)
+            for (label i = 0; i < mSize; i++)
             {
                 // Fetch the global face index
                 label mfIndex = (mStart + i);
@@ -6913,160 +7529,129 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
                 // Fetch pointFaces for the zeroth point.
                 const labelList& spFaces = spF[cFace[0]];
 
-                if (twoDMesh_)
+                label sFaceIndex = -1, compareVal = -1;
+
+                forAll(spFaces, faceJ)
                 {
-                    bool matched = false;
+                    // Fetch the global face index
+                    label sfIndex = spFaces[faceJ];
 
-                    forAll(spFaces, faceJ)
+                    const face& sFace = slaveFaces[sfIndex];
+
+                    // Check for triangle face optimization
+                    if (mFace.size() == 3)
                     {
-                        // 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
+                        compareVal =
                         (
                             triFace::compare
                             (
                                 triFace(cFace[0], cFace[1], cFace[2]),
                                 triFace(sFace[0], sFace[1], sFace[2])
                             )
-                        )
+                        );
+                    }
+                    else
+                    {
+                        compareVal = face::compare(cFace, sFace);
+                    }
+
+                    if (compareVal)
+                    {
+                        // 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;
+                }
+
+                // No need to match edges in 2D
+                if (is2D())
+                {
+                    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::FACE,
-                                mfIndex,
-                                sfIndex
+                                coupleMap::EDGE,
+                                mfEdges[edgeI],
+                                sfEdges[edgeJ]
                             );
 
                             cMap.mapMaster
                             (
-                                coupleMap::FACE,
-                                sfIndex,
-                                mfIndex
+                                coupleMap::EDGE,
+                                sfEdges[edgeJ],
+                                mfEdges[edgeI]
                             );
 
-                            sFaceIndex = sfIndex;
+                            matchedEdge = true;
 
                             break;
                         }
                     }
 
-                    if (sFaceIndex == -1)
+                    if (!matchedEdge)
                     {
-                        unMatchedFaces.insert(mfIndex);
+                        // Write out the edge
+                        writeVTK("mEdge", mfEdges[edgeI], 1);
 
-                        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);
-                        }
+                        FatalErrorIn
+                        (
+                            "void dynamicTopoFvMesh::"
+                            "buildProcessorCoupledMaps()"
+                        )
+                            << " Failed to match edge: "
+                            << mfEdges[edgeI] << ": "
+                            << mEdge << nl
+                            << " cEdge: " << cEdge
+                            << " for processor: " << proc
+                            << abort(FatalError);
                     }
                 }
             }
@@ -7074,7 +7659,7 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
 
         // Attempt to match other edges in 3D, provided any common ones exist.
         //  - This will handle point-only coupling situations for edges.
-        if (!twoDMesh_)
+        if (is3D())
         {
             // Fetch Maps for this processor
             const Map<label>& edgeMap = cMap.entityMap(coupleMap::EDGE);
@@ -7148,6 +7733,80 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
                     }
                 }
             }
+
+            // Prepare processor point and edge maps
+            //  - For each point / edge on the subMesh, create
+            //    a list of processors (other than this one)
+            //    that are connected to it
+            Map<labelList>& pEdgeMap = cMap.subMeshEdgeMap();
+            Map<labelList>& pPointMap = cMap.subMeshPointMap();
+
+            const dynamicTopoFvMesh& sMesh = rPM.subMesh();
+            const polyBoundaryMesh& bdy = sMesh.boundaryMesh();
+
+            forAll(bdy, pI)
+            {
+                if (!isA<processorPolyPatch>(bdy[pI]))
+                {
+                    continue;
+                }
+
+                const processorPolyPatch& pp =
+                (
+                    refCast<const processorPolyPatch>(bdy[pI])
+                );
+
+                label neiProcNo = pp.neighbProcNo();
+                label myProcNo = Pstream::myProcNo();
+
+                if (neiProcNo == myProcNo)
+                {
+                    continue;
+                }
+
+                label mStart = pp.start();
+                label mSize  = pp.size();
+
+                for (label i = 0; i < mSize; i++)
+                {
+                    const face& f = sMesh.faces_[i + mStart];
+                    const labelList& fe = sMesh.faceEdges_[i + mStart];
+
+                    forAll(f, j)
+                    {
+                        const label pIndex = f[j];
+                        const label eIndex = fe[j];
+
+                        Map<labelList>::iterator pIt = pPointMap.find(pIndex);
+
+                        if (pIt == pPointMap.end())
+                        {
+                            pPointMap.insert(pIndex, labelList(1, neiProcNo));
+                        }
+                        else
+                        {
+                            if (findIndex(pIt(), neiProcNo) == -1)
+                            {
+                                meshOps::sizeUpList(neiProcNo, pIt());
+                            }
+                        }
+
+                        Map<labelList>::iterator eIt = pEdgeMap.find(eIndex);
+
+                        if (eIt == pEdgeMap.end())
+                        {
+                            pEdgeMap.insert(eIndex, labelList(1, neiProcNo));
+                        }
+                        else
+                        {
+                            if (findIndex(eIt(), neiProcNo) == -1)
+                            {
+                                meshOps::sizeUpList(neiProcNo, eIt());
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         if (unMatchedFaces.size())
@@ -7163,6 +7822,82 @@ void dynamicTopoFvMesh::buildProcessorCoupledMaps()
                 << abort(FatalError);
         }
     }
+
+    // Use subMesh and global points to identify additional
+    // processors, and update maps accordingly
+    if (is3D())
+    {
+        forAll(procIndices_, pI)
+        {
+            const label neiProcNo = procIndices_[pI];
+            const coupleMap& cMi = recvMeshes_[pI].map();
+
+            const labelList& smPts = cMi.subMeshPoints();
+            const List<labelPair>& gpp = cMi.globalProcPoints();
+
+            forAll(procIndices_, pJ)
+            {
+                if (pJ == pI)
+                {
+                    continue;
+                }
+
+                const coupleMap& cMj = recvMeshes_[pJ].map();
+
+                Map<labelList>& pPointMap = cMj.subMeshPointMap();
+
+                forAll(smPts, pointI)
+                {
+                    label mP = smPts[pointI];
+                    label sP = cMj.findSlave(coupleMap::POINT, mP);
+
+                    if (sP == -1)
+                    {
+                        continue;
+                    }
+
+                    Map<labelList>::iterator pIt = pPointMap.find(sP);
+
+                    if (pIt == pPointMap.end())
+                    {
+                        pPointMap.insert(sP, labelList(1, neiProcNo));
+                    }
+                    else
+                    {
+                        if (findIndex(pIt(), neiProcNo) == -1)
+                        {
+                            meshOps::sizeUpList(neiProcNo, pIt());
+                        }
+                    }
+                }
+
+                forAll(gpp, pointI)
+                {
+                    label mP = gpp[pointI].first();
+                    label sP = cMj.findSlave(coupleMap::POINT, mP);
+
+                    if (sP == -1)
+                    {
+                        continue;
+                    }
+
+                    Map<labelList>::iterator pIt = pPointMap.find(sP);
+
+                    if (pIt == pPointMap.end())
+                    {
+                        pPointMap.insert(sP, labelList(1, neiProcNo));
+                    }
+                    else
+                    {
+                        if (findIndex(pIt(), neiProcNo) == -1)
+                        {
+                            meshOps::sizeUpList(neiProcNo, pIt());
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 
@@ -7174,13 +7909,24 @@ label dynamicTopoFvMesh::createProcessorPatch(const label proc)
         return -2;
     }
 
+    // Find index in list of processors
+    label pI = findIndex(procIndices_, proc);
+
+    // Check if an entry already exists
+    if (pI > -1)
+    {
+        label patchIndex = sendMeshes_[pI].map().patchIndex();
+
+        if (patchIndex > -1)
+        {
+            return patchIndex;
+        }
+    }
+
     // 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_)
     {
@@ -7192,16 +7938,16 @@ label dynamicTopoFvMesh::createProcessorPatch(const label proc)
             sendMeshes_.setSize(pI + 1);
         }
 
-        // Create a basic entry
+        // Create a basic entry on the subMesh
         procIndices_[pI] = proc;
 
         sendMeshes_.set
         (
             pI,
-            new coupledInfo
+            new coupledMesh
             (
                 *this,               // Reference to this mesh
-                twoDMesh_,           // 2D or 3D
+                is2D(),              // 2D or 3D
                 false,               // Not local
                 true,                // Sent to neighbour
                 patchID,             // Patch index
@@ -7261,9 +8007,11 @@ label dynamicTopoFvMesh::createProcessorPatch(const label proc)
     {
         Pout<< " dynamicTopoFvMesh::createProcessorPatch :"
             << " Created new patch for processor: " << proc << nl
-            << " On subMesh: " << Switch::asText(isSubMesh_) << nl
+            << " On subMesh: " << isSubMesh_ << nl
             << " pI: " << pI << nl
             << " patchID: " << patchID << nl
+            << " oldPatchStarts: " << oldPatchStarts_ << nl
+            << " oldPatchSizes: " << oldPatchSizes_ << nl
             << " patchStarts: " << patchStarts_ << nl
             << " patchSizes: " << patchSizes_ << nl
             << endl;
@@ -7343,17 +8091,19 @@ void dynamicTopoFvMesh::resetBoundaries()
     // Fetch reference to existing boundary
     // - The removeBoundary member merely resets
     //   boundary size, so this reference is safe
-    const polyBoundaryMesh& boundary = boundaryMesh();
+    const polyBoundaryMesh& polyBoundary = boundaryMesh();
 
     // Copy all existing patches first
-    for (label patchI = 0; patchI < boundaryMesh().size(); patchI++)
+    label nOldPatches = polyBoundary.size();
+
+    for (label patchI = 0; patchI < nOldPatches; patchI++)
     {
         // Clone the patch
-        patches[patchI] = boundary[patchI].clone(boundary).ptr();
+        patches[patchI] = polyBoundary[patchI].clone(polyBoundary).ptr();
     }
 
     // Create new processor patches
-    for (label patchI = boundaryMesh().size(); patchI < nPatches_; patchI++)
+    for (label patchI = nOldPatches; patchI < nPatches_; patchI++)
     {
         // Make a temporary dictionary for patch construction
         dictionary patchDict;
@@ -7363,8 +8113,8 @@ void dynamicTopoFvMesh::resetBoundaries()
 
         // Add relevant info
         patchDict.add("type", "processor");
-        patchDict.add("startFace", patchStarts_[patchI]);
-        patchDict.add("nFaces", patchSizes_[patchI]);
+        patchDict.add("startFace", oldPatchStarts_[patchI]);
+        patchDict.add("nFaces", oldPatchSizes_[patchI]);
         patchDict.add("myProcNo", Pstream::myProcNo());
         patchDict.add("neighbProcNo", neiProcNo);
 
@@ -7379,7 +8129,7 @@ void dynamicTopoFvMesh::resetBoundaries()
               + Foam::name(neiProcNo),
                 patchDict,
                 patchI,
-                boundary
+                polyBoundary
             ).ptr()
         );
     }
@@ -7389,6 +8139,54 @@ void dynamicTopoFvMesh::resetBoundaries()
 
     // Add patches, but don't calculate geometry, etc
     fvMesh::addFvPatches(patches, false);
+
+    // Since all fvPatches in fvBoundaryMesh have been reset,
+    // fvPatch references in all fvPatchFields are no longer
+    // valid, and must therefore be remapped.
+    const fvBoundaryMesh& bdy = fvMesh::boundary();
+
+    coupledMesh::resizeBoundaries<volScalarField>(*this, bdy);
+    coupledMesh::resizeBoundaries<volVectorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<volSphericalTensorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<volSymmTensorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<volTensorField>(*this, bdy);
+
+    coupledMesh::resizeBoundaries<surfaceScalarField>(*this, bdy);
+    coupledMesh::resizeBoundaries<surfaceVectorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<surfaceSphericalTensorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<surfaceSymmTensorField>(*this, bdy);
+    coupledMesh::resizeBoundaries<surfaceTensorField>(*this, bdy);
+}
+
+
+// Convenience macro for field sub-setting
+#define sendFieldsOfType(type, info, names, types, offset, map, stream)        \
+{                                                                              \
+    {                                                                          \
+        scalar zeroValue = pTraits<scalar>::zero;                              \
+        info.send<type##ScalarField>                                           \
+        (names[0 + offset], types[0 + offset], zeroValue, map, stream);        \
+    }                                                                          \
+    {                                                                          \
+        vector zeroValue = pTraits<vector>::zero;                              \
+        info.send<type##VectorField>                                           \
+        (names[1 + offset], types[1 + offset], zeroValue, map, stream);        \
+    }                                                                          \
+    {                                                                          \
+        sphericalTensor zeroValue = pTraits<sphericalTensor>::zero;            \
+        info.send<type##SphericalTensorField>                                  \
+        (names[2 + offset], types[2 + offset], zeroValue, map, stream);        \
+    }                                                                          \
+    {                                                                          \
+        symmTensor zeroValue = pTraits<symmTensor>::zero;                      \
+        info.send<type##SymmTensorField>                                       \
+        (names[3 + offset], types[3 + offset], zeroValue, map, stream);        \
+    }                                                                          \
+    {                                                                          \
+        tensor zeroValue = pTraits<tensor>::zero;                              \
+        info.send<type##TensorField>                                           \
+        (names[4 + offset], types[4 + offset], zeroValue, map, stream);        \
+    }                                                                          \
 }
 
 
@@ -7421,10 +8219,8 @@ void dynamicTopoFvMesh::initFieldTransfers
     // 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);
+    names.setSize(10);
+    types.setSize(10);
 
     // Fill in field-types
     types[0] = volScalarField::typeName;
@@ -7439,15 +8235,9 @@ void dynamicTopoFvMesh::initFieldTransfers
     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);
@@ -7459,18 +8249,12 @@ void dynamicTopoFvMesh::initFieldTransfers
         OStringStream& fNStream = fieldNameStream[0];
 
         // Fetch field-names by type
-        for (label typeI = 0; typeI < 10; typeI++)
+        forAll(types, 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;
 
@@ -7545,84 +8329,20 @@ void dynamicTopoFvMesh::initFieldTransfers
     {
         label proc = procIndices_[pI];
 
-        const coupledInfo& cInfo = sendMeshes_[pI];
+        const coupledMesh& 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 and send volFields to stream
+        const labelList& cMap = cInfo.map().cellMap();
 
-        // 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]);
+        sendFieldsOfType(vol, cInfo, names, types, 0, cMap, stream[pI]);
 
-        // Subset scalar gradients to stream
-        stream[pI]
-            << types[10] << token::NL
-            << token::BEGIN_BLOCK << token::NL;
+        // Subset and send surfaceFields to stream
+        const labelList& fMap = cInfo.map().internalFaceMap();
 
-        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;
+        sendFieldsOfType(surface, cInfo, names, types, 5, fMap, stream[pI]);
 
         // Size up buffers and fill contents
         string contents = stream[pI].str();
@@ -7700,22 +8420,14 @@ void dynamicTopoFvMesh::syncFieldTransfers
     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();
+    const polyBoundaryMesh& polyBoundary = boundaryMesh();
 
     // Determine number of physical (non-processor) patches
     label nPhysical = 0;
 
-    forAll(boundary, patchI)
+    forAll(polyBoundary, patchI)
     {
-        if (isA<processorPolyPatch>(boundary[patchI]))
+        if (isA<processorPolyPatch>(polyBoundary[patchI]))
         {
             continue;
         }
@@ -7733,7 +8445,7 @@ void dynamicTopoFvMesh::syncFieldTransfers
 
     forAll(procIndices_, pI)
     {
-        const coupledInfo& cInfo = recvMeshes_[pI];
+        const coupledMesh& cInfo = recvMeshes_[pI];
 
         // Convert buffer to string
         string contents(recvBuffer[pI].begin(), recvBuffer[pI].size());
@@ -7744,25 +8456,6 @@ void dynamicTopoFvMesh::syncFieldTransfers
         // 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();
 
@@ -7770,6 +8463,19 @@ void dynamicTopoFvMesh::syncFieldTransfers
         label nCells = cMap.nEntities(coupleMap::CELL);
         label nIntFaces = cMap.nEntities(coupleMap::INTERNAL_FACE);
 
+        // Set field pointers
+        cInfo.setField(names[0], dict.subDict(types[0]), nCells, vsF[pI]);
+        cInfo.setField(names[1], dict.subDict(types[1]), nCells, vvF[pI]);
+        cInfo.setField(names[2], dict.subDict(types[2]), nCells, vsptF[pI]);
+        cInfo.setField(names[3], dict.subDict(types[3]), nCells, vsytF[pI]);
+        cInfo.setField(names[4], dict.subDict(types[4]), nCells, vtF[pI]);
+
+        cInfo.setField(names[5], dict.subDict(types[5]), nIntFaces, ssF[pI]);
+        cInfo.setField(names[6], dict.subDict(types[6]), nIntFaces, svF[pI]);
+        cInfo.setField(names[7], dict.subDict(types[7]), nIntFaces, ssptF[pI]);
+        cInfo.setField(names[8], dict.subDict(types[8]), nIntFaces, ssytF[pI]);
+        cInfo.setField(names[9], dict.subDict(types[9]), nIntFaces, stF[pI]);
+
         // Set rmap for this processor
         irvMaps[pI] = (labelField(identity(nCells)) + nTotalCells);
         irsMaps[pI] = (labelField(identity(nIntFaces)) + nTotalIntFaces);
@@ -7820,13 +8526,13 @@ void dynamicTopoFvMesh::syncFieldTransfers
         faceAddressing[i] = i;
     }
 
-    coupledInfo::subMeshMapper vMap
+    coupledMesh::subMeshMapper vMap
     (
         nOldCells_,
         cellAddressing
     );
 
-    coupledInfo::subMeshMapper sMap
+    coupledMesh::subMeshMapper sMap
     (
         nOldInternalFaces_,
         faceAddressing
@@ -7834,7 +8540,7 @@ void dynamicTopoFvMesh::syncFieldTransfers
 
     // Prepare boundary mappers
     labelListList patchAddressing(nPhysical);
-    PtrList<coupledInfo::subMeshMapper> bMap(nPhysical);
+    PtrList<coupledMesh::subMeshMapper> bMap(nPhysical);
 
     forAll(bMap, patchI)
     {
@@ -7852,7 +8558,7 @@ void dynamicTopoFvMesh::syncFieldTransfers
         bMap.set
         (
             patchI,
-            new coupledInfo::subMeshMapper
+            new coupledMesh::subMeshMapper
             (
                 oldPatchSizes_[patchI],
                 patchAddressing[patchI]
@@ -7862,49 +8568,17 @@ void dynamicTopoFvMesh::syncFieldTransfers
 
     // 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);
+    coupledMesh::resizeMap(names[0], *this, vMap, irvMaps, bMap, brMaps, vsF);
+    coupledMesh::resizeMap(names[1], *this, vMap, irvMaps, bMap, brMaps, vvF);
+    coupledMesh::resizeMap(names[2], *this, vMap, irvMaps, bMap, brMaps, vsptF);
+    coupledMesh::resizeMap(names[3], *this, vMap, irvMaps, bMap, brMaps, vsytF);
+    coupledMesh::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);
+    coupledMesh::resizeMap(names[5], *this, sMap, irsMaps, bMap, brMaps, ssF);
+    coupledMesh::resizeMap(names[6], *this, sMap, irsMaps, bMap, brMaps, svF);
+    coupledMesh::resizeMap(names[7], *this, sMap, irsMaps, bMap, brMaps, ssptF);
+    coupledMesh::resizeMap(names[8], *this, sMap, irsMaps, bMap, brMaps, ssytF);
+    coupledMesh::resizeMap(names[9], *this, sMap, irsMaps, bMap, brMaps, stF);
 }
 
 
@@ -8027,9 +8701,6 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
 {
     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_);
@@ -8090,7 +8761,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                     maxLen = max(maxLen, mag(points_[sFace[fpI]] - sfc));
                 }
 
-                slaveTols[slavePatch][fI] = matchTol*maxLen;
+                slaveTols[slavePatch][fI] = geomMatchTol_ * maxLen;
             }
 
             // For cyclics, additionally test for halves,
@@ -8160,8 +8831,8 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                         else
                         {
                             // Assume constant transform tensor
-                            mA = Foam::transform(cyclicPatch.transformT(0), mA);
-                            mC = Foam::transform(cyclicPatch.transformT(0), mC);
+                            mA = Foam::transform(cyclicPatch.forwardT()[0], mA);
+                            mC = Foam::transform(cyclicPatch.forwardT()[0], mC);
                         }
 
                         // Set the transformed anchor / centre
@@ -8221,6 +8892,8 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
             // Try zero separation automatic matching
             bool matchedAll =
             (
+                (mSize == sSize)
+             &&
                 matchPoints
                 (
                     slaveCentres[slavePatch],
@@ -8442,7 +9115,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                     maxLen = max(maxLen, mag(points_[checkFace[fpI]] - fc));
                 }
 
-                slaveTols[pI][fI] = matchTol*maxLen;
+                slaveTols[pI][fI] = geomMatchTol_ * maxLen;
             }
 
             // Write out my centres to disk
@@ -8493,8 +9166,13 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
         else
         {
             // Try zero separation automatic matching
+            label mSize = centres[pI].size();
+            label sSize = slaveCentres[pI].size();
+
             bool matchedAll =
             (
+                (mSize == sSize)
+             &&
                 matchPoints
                 (
                     slaveCentres[pI],
@@ -8508,9 +9186,6 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
             // Write out centres to disk
             if (debug > 3 || !matchedAll)
             {
-                label mSize = centres[pI].size();
-                label sSize = slaveCentres[pI].size();
-
                 meshOps::writeVTK
                 (
                     (*this),
@@ -8539,7 +9214,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
                   + Foam::name(Pstream::myProcNo())
                   + '_'
                   + Foam::name(neiProcNo),
-                    identity(mSize) + patchStarts_[pI],
+                    identity(patchSizes_[pI]) + patchStarts_[pI],
                     2, false, true
                 );
 
@@ -8645,7 +9320,7 @@ bool dynamicTopoFvMesh::syncCoupledBoundaryOrdering
               + '_'
               + Foam::name(neiProcNo),
                 identity(patchSizes_[pI]) + patchStarts_[pI],
-                2
+                2, false, true
             );
         }
 
@@ -8686,8 +9361,8 @@ void dynamicTopoFvMesh::exchangeLengthBuffers()
 
     forAll(procIndices_, pI)
     {
-        coupledInfo& sPM = sendMeshes_[pI];
-        coupledInfo& rPM = recvMeshes_[pI];
+        coupledMesh& sPM = sendMeshes_[pI];
+        coupledMesh& rPM = recvMeshes_[pI];
 
         const coupleMap& scMap = sPM.map();
         const coupleMap& rcMap = rPM.map();
@@ -8764,7 +9439,7 @@ void dynamicTopoFvMesh::exchangeLengthBuffers()
     {
         forAll(procIndices_, pI)
         {
-            const coupledInfo& rPM = recvMeshes_[pI];
+            const coupledMesh& rPM = recvMeshes_[pI];
             const coupleMap& rcMap = rPM.map();
 
             if (rcMap.masterIndex() == Pstream::myProcNo())
@@ -8886,7 +9561,11 @@ bool dynamicTopoFvMesh::coupledFillTables
             label fPatch = whichPatch(eFaces[faceI]);
             label neiProc = getNeighbourProcessor(fPatch);
 
-            if (neiProc > -1 && neiProc < Pstream::myProcNo())
+            if
+            (
+                neiProc > -1
+             && priority(neiProc, lessOp<label>(), Pstream::myProcNo())
+            )
             {
                 // This edge should not be here
                 Pout<< " Edge: " << eIndex
@@ -8993,7 +9672,11 @@ bool dynamicTopoFvMesh::coupledFillTables
                 // skip the insertion step.
                 label neiProc = mesh.getNeighbourProcessor(slavePatch);
 
-                if (neiProc > -1 && neiProc < proc)
+                if
+                (
+                    neiProc > -1
+                 && priority(neiProc, lessOp<label>(), proc)
+                )
                 {
                     continue;
                 }
@@ -9102,10 +9785,12 @@ bool dynamicTopoFvMesh::coupledFillTables
 
             if (minQuality < 0.0)
             {
+                Switch isClosed(closed);
+
                 Pout<< " * * * Error in fillTables * * * " << nl
                     << " Edge: " << eIndex << " :: " << checkEdge << nl
                     << " minQuality: " << minQuality << nl
-                    << " Closed: " << Switch::asText(closed) << nl
+                    << " Closed: " << isClosed << nl
                     << abort(FatalError);
             }
         }
@@ -9159,6 +9844,33 @@ bool dynamicTopoFvMesh::coupledFillTables
 }
 
 
+// Initialize coupled weights calculation
+void dynamicTopoFvMesh::initCoupledWeights()
+{
+    if (!Pstream::parRun())
+    {
+        return;
+    }
+
+    forAll(procIndices_, pI)
+    {
+        // Fetch reference to subMesh
+        const dynamicTopoFvMesh& mesh = recvMeshes_[pI].subMesh();
+
+        mesh.cells();
+        mesh.cellCells();
+        mesh.cellPoints();
+
+        const polyBoundaryMesh& sBoundary = mesh.boundaryMesh();
+
+        forAll(sBoundary, patchI)
+        {
+            sBoundary[patchI].faceFaces();
+        }
+    }
+}
+
+
 // Additional mapping contributions for coupled entities
 void dynamicTopoFvMesh::computeCoupledWeights
 (
@@ -9372,7 +10084,7 @@ scalar dynamicTopoFvMesh::processorLengthScale(const label index) const
 {
     scalar procScale = 0.0;
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // First check the master processor
         procScale += lengthScale_[owner_[index]];
@@ -9638,7 +10350,7 @@ bool dynamicTopoFvMesh::locallyCoupledEntity
         return false;
     }
 
-    if (twoDMesh_ || checkFace)
+    if (is2D() || checkFace)
     {
         label patch = whichPatch(index);
 
@@ -9803,7 +10515,7 @@ bool dynamicTopoFvMesh::processorCoupledEntity
 
     label patch = -2;
 
-    if ((twoDMesh_ || checkFace) && !checkEdge)
+    if ((is2D() || checkFace) && !checkEdge)
     {
         patch = whichPatch(index);
 
@@ -9972,7 +10684,7 @@ void dynamicTopoFvMesh::buildEntitiesToAvoid
             getNeighbourProcessor(pIndex) > -1
         )
         {
-            if (twoDMesh_)
+            if (is2D())
             {
                 // Avoid this face during regular modification.
                 if (!entities.found(faceI))
@@ -10008,7 +10720,7 @@ void dynamicTopoFvMesh::buildEntitiesToAvoid
             {
                 forAllConstIter(Map<label>, rEdgeMap, eIter)
                 {
-                    if (twoDMesh_)
+                    if (is2D())
                     {
                         const labelList& eFaces = edgeFaces_[eIter.key()];
 
@@ -10057,7 +10769,7 @@ void dynamicTopoFvMesh::buildEntitiesToAvoid
         if (debug > 4)
         {
             // Write out entities
-            label elemType = twoDMesh_ ? 2 : 1;
+            label elemType = is2D() ? 2 : 1;
 
             writeVTK
             (
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshLduAddressing.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshLduAddressing.H
new file mode 100644
index 000000000..a42732eab
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshLduAddressing.H
@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    subMeshLduAddressing
+
+Description
+    Customized lduAddressing for subMeshes
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef subMeshLduAddressing_H
+#define subMeshLduAddressing_H
+
+#include "lduAddressing.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class subMeshLduAddressing Declaration
+\*---------------------------------------------------------------------------*/
+
+class subMeshLduAddressing
+:
+    public lduAddressing
+{
+    // Private data
+
+        //- Lower as a subList of allOwner
+        labelList::subList lowerAddr_;
+
+        //- Upper as a reference to neighbour
+        const labelList& upperAddr_;
+
+        //- Number of patches
+        label nPatches_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        subMeshLduAddressing(const subMeshLduAddressing&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const subMeshLduAddressing&);
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        subMeshLduAddressing(const fvMesh& mesh)
+        :
+            lduAddressing(mesh.nCells()),
+            lowerAddr_
+            (
+                labelList::subList
+                (
+                    mesh.faceOwner(),
+                    mesh.nInternalFaces()
+                )
+            ),
+            upperAddr_(mesh.faceNeighbour()),
+            nPatches_(mesh.boundary().size())
+        {}
+
+    // Destructor
+
+        virtual ~subMeshLduAddressing()
+        {}
+
+    // Member Functions
+
+        //- Return number of interfaces
+        virtual label nPatches() const
+        {
+            return nPatches_;
+        }
+
+        //- Return lower addressing (i.e. lower label = upper triangle)
+        virtual const unallocLabelList& lowerAddr() const
+        {
+            return lowerAddr_;
+        }
+
+        //- Return upper addressing (i.e. upper label)
+        virtual const unallocLabelList& upperAddr() const
+        {
+            return upperAddr_;
+        }
+
+        //- Return patch addressing
+        virtual const unallocLabelList& patchAddr(const label i) const
+        {
+            FatalErrorIn
+            (
+                "void subMeshLduAddressing::patchAddr(const label i)"
+            )
+                << " Illegal request. "
+                << abort(FatalError);
+
+            return unallocLabelList::null();
+        }
+
+        // Return patch field evaluation schedule
+        virtual const lduSchedule& patchSchedule() const
+        {
+            FatalErrorIn
+            (
+                "void subMeshLduAddressing::patchSchedule()"
+            )
+                << " Illegal request. "
+                << abort(FatalError);
+
+            return lduSchedule::null();
+        }
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.C
new file mode 100644
index 000000000..697602189
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.C
@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    subMeshProcessorFvPatch
+
+Description
+    Functions specific to subMeshProcessorFvPatch
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "subMeshProcessorFvPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(subMeshProcessorFvPatch, 0);
+addToRunTimeSelectionTable(fvPatch, subMeshProcessorFvPatch, polyPatch);
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void subMeshProcessorFvPatch::makeWeights(scalarField& w) const
+{
+    w = 1.0;
+}
+
+
+void subMeshProcessorFvPatch::makeDeltaCoeffs(scalarField& dc) const
+{
+    dc = 1.0/(nf() & fvPatch::delta());
+}
+
+
+tmp<vectorField> subMeshProcessorFvPatch::delta() const
+{
+    return fvPatch::delta();
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.H
new file mode 100644
index 000000000..468397c09
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorFvPatch.H
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    subMeshProcessorFvPatch
+
+Description
+    Customized processor type for subMeshes.
+
+    The intent of this class is to provide processor patch information
+    on subMeshes, but avoiding all forms of communication.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef subMeshProcessorFvPatch_H
+#define subMeshProcessorFvPatch_H
+
+#include "processorFvPatch.H"
+#include "subMeshProcessorPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class subMeshProcessorFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class subMeshProcessorFvPatch
+:
+    public processorFvPatch
+{
+    // Private Data
+
+        const subMeshProcessorPolyPatch& procPolyPatch_;
+
+protected:
+
+    // Protected Member Functions
+
+        //- Make patch weighting factors
+        void makeWeights(scalarField&) const;
+
+        //- Make patch face - neighbour cell distances
+        void makeDeltaCoeffs(scalarField&) const;
+
+public:
+
+    //- Runtime type information
+    TypeName(subMeshProcessorPolyPatch::typeName_());
+
+    // Constructors
+
+        //- Construct from components
+        subMeshProcessorFvPatch
+        (
+            const polyPatch& patch,
+            const fvBoundaryMesh& bm
+        )
+        :
+            processorFvPatch(patch, bm),
+            procPolyPatch_(refCast<const subMeshProcessorPolyPatch>(patch))
+        {}
+
+    // Destructor
+
+        virtual ~subMeshProcessorFvPatch()
+        {}
+
+    // Member functions
+
+        //- Return delta (P to N) vectors across coupled patch
+        virtual tmp<vectorField> delta() const;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.C
new file mode 100644
index 000000000..01a9328a0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.C
@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    subMeshProcessorPolyPatch
+
+Description
+    Functions specific to subMeshProcessorPolyPatch
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "subMeshProcessorPolyPatch.H"
+#include "addToRunTimeSelectionTable.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(subMeshProcessorPolyPatch, 0);
+addToRunTimeSelectionTable(polyPatch, subMeshProcessorPolyPatch, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+subMeshProcessorPolyPatch::subMeshProcessorPolyPatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const polyBoundaryMesh& bm,
+    const int myProcNo,
+    const int neighbProcNo
+)
+:
+    processorPolyPatch
+    (
+        name,
+        size,
+        start,
+        index,
+        bm,
+        myProcNo,
+        neighbProcNo
+    )
+{}
+
+
+subMeshProcessorPolyPatch::subMeshProcessorPolyPatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const polyBoundaryMesh& bm
+)
+:
+    processorPolyPatch(name, dict, index, bm)
+{}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+subMeshProcessorPolyPatch::~subMeshProcessorPolyPatch()
+{}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.H
new file mode 100644
index 000000000..df92816fb
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/coupledMesh/subMeshProcessorPolyPatch.H
@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     |
+    \\  /    A nd           | For copyright notice see file Copyright
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation, either version 3 of the License, or (at your
+    option) any later version.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    subMeshProcessorPolyPatch
+
+Description
+    Customized processor type for subMeshes.
+
+    The intent of this class is to provide processor patch information
+    on subMeshes, but avoiding all forms of communication.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef subMeshProcessorPolyPatch_H
+#define subMeshProcessorPolyPatch_H
+
+#include "processorPolyPatch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class subMeshProcessorPolyPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class subMeshProcessorPolyPatch
+:
+    public processorPolyPatch
+{
+
+public:
+
+    //- Runtime type information
+    TypeName("subMeshProcessor");
+
+    // Constructors
+
+        //- Construct from components
+        subMeshProcessorPolyPatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const polyBoundaryMesh& bm,
+            const int myProcNo,
+            const int neighbProcNo
+        );
+
+        //- Construct from dictionary
+        subMeshProcessorPolyPatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const polyBoundaryMesh&
+        );
+
+    // Destructor
+
+        virtual ~subMeshProcessorPolyPatch();
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
index f618e4868..4ce6e0aa7 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
@@ -52,6 +52,7 @@ Author
 #include "motionSolver.H"
 #include "fvPatchFields.H"
 #include "fvsPatchFields.H"
+#include "subMeshLduAddressing.H"
 #include "lengthScaleEstimator.H"
 #include "conservativeMapFields.H"
 
@@ -98,6 +99,7 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     loadMotionSolver_(true),
     bandWidthReduction_(false),
     coupledModification_(false),
+    lduPtr_(NULL),
     interval_(1),
     eMeshPtr_(NULL),
     mapper_(NULL),
@@ -132,7 +134,7 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     nOldInternalEdges_(0),
     nInternalEdges_(0),
     maxModifications_(-1),
-    statistics_(0),
+    statistics_(TOTAL_OP_TYPES, 0),
     sliverThreshold_(0.1),
     slicePairs_(0),
     maxTetsPerEdge_(-1),
@@ -175,12 +177,6 @@ dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
     // 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();
@@ -227,6 +223,7 @@ dynamicTopoFvMesh::dynamicTopoFvMesh
     loadMotionSolver_(mesh.loadMotionSolver_),
     bandWidthReduction_(mesh.bandWidthReduction_),
     coupledModification_(false),
+    lduPtr_(NULL),
     interval_(1),
     eMeshPtr_(NULL),
     mapper_(NULL),
@@ -261,7 +258,7 @@ dynamicTopoFvMesh::dynamicTopoFvMesh
     nOldInternalEdges_(edgeStarts[0]),
     nInternalEdges_(edgeStarts[0]),
     maxModifications_(mesh.maxModifications_),
-    statistics_(0),
+    statistics_(TOTAL_OP_TYPES, 0),
     sliverThreshold_(mesh.sliverThreshold_),
     slicePairs_(0),
     maxTetsPerEdge_(mesh.maxTetsPerEdge_),
@@ -326,7 +323,7 @@ dynamicTopoFvMesh::dynamicTopoFvMesh
     // Now build edgeFaces and pointEdges information.
     edgeFaces_ = invertManyToMany<labelList, labelList>(nEdges_, faceEdges_);
 
-    if (!twoDMesh_)
+    if (is3D())
     {
         pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
     }
@@ -336,7 +333,9 @@ dynamicTopoFvMesh::dynamicTopoFvMesh
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 dynamicTopoFvMesh::~dynamicTopoFvMesh()
-{}
+{
+    deleteDemandDrivenData(lduPtr_);
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
@@ -469,6 +468,7 @@ label dynamicTopoFvMesh::insertFace
     const face& newFace,
     const label newOwner,
     const label newNeighbour,
+    const labelList& newFaceEdges,
     const label zoneID
 )
 {
@@ -480,6 +480,7 @@ label dynamicTopoFvMesh::insertFace
     faces_.append(newFace);
     owner_.append(newOwner);
     neighbour_.append(newNeighbour);
+    faceEdges_.append(newFaceEdges);
 
     if (debug > 2)
     {
@@ -487,7 +488,8 @@ label dynamicTopoFvMesh::insertFace
             << newFaceIndex << ": "
             << newFace
             << " Owner: " << newOwner
-            << " Neighbour: " << newNeighbour;
+            << " Neighbour: " << newNeighbour
+            << " faceEdges: " << newFaceEdges;
 
         const polyBoundaryMesh& boundary = boundaryMesh();
 
@@ -510,7 +512,7 @@ label dynamicTopoFvMesh::insertFace
 
     // Keep track of added boundary faces in a separate hash-table
     // This information will be required at the reordering stage
-    addedFacePatches_.insert(newFaceIndex,patch);
+    addedFacePatches_.insert(newFaceIndex, patch);
 
     if (newNeighbour == -1)
     {
@@ -814,7 +816,7 @@ label dynamicTopoFvMesh::insertEdge
     }
 
     // Size-up the pointEdges list
-    if (!twoDMesh_)
+    if (is3D())
     {
         meshOps::sizeUpList(newEdgeIndex, pointEdges_[newEdge[0]]);
         meshOps::sizeUpList(newEdgeIndex, pointEdges_[newEdge[1]]);
@@ -833,7 +835,7 @@ void dynamicTopoFvMesh::removeEdge
     const label eIndex
 )
 {
-    if (!twoDMesh_)
+    if (is3D())
     {
         const edge& rEdge = edges_[eIndex];
 
@@ -978,7 +980,7 @@ label dynamicTopoFvMesh::insertPoint
 
     // Add an empty entry to pointEdges as well.
     // This entry can be sized-up appropriately at a later stage.
-    if (!twoDMesh_)
+    if (is3D())
     {
         pointEdges_.append(labelList(0));
     }
@@ -1015,7 +1017,7 @@ void dynamicTopoFvMesh::removePoint
     // oldPoints_[pIndex] = point();
 
     // Remove pointEdges as well
-    if (!twoDMesh_)
+    if (is3D())
     {
         pointEdges_[pIndex].clear();
     }
@@ -1394,7 +1396,7 @@ void dynamicTopoFvMesh::handleMeshSlicing()
 
         bool available = true;
 
-        if (twoDMesh_)
+        if (is2D())
         {
             forAll(pairToCheck, indexI)
             {
@@ -1544,7 +1546,7 @@ scalar dynamicTopoFvMesh::testProximity
     scalar proxDistance = GREAT, testStep = 0.0;
     vector gCentre = vector::zero, gNormal = vector::zero;
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // Obtain the face-normal.
         gNormal = faces_[index].normal(points_);
@@ -1613,7 +1615,7 @@ scalar dynamicTopoFvMesh::testProximity
         labelPair proxPoints(-1, -1);
         bool foundPoint = false;
 
-        if (twoDMesh_)
+        if (is2D())
         {
             proxPoints.first() = index;
             proxPoints.second() = proximityFace;
@@ -1744,16 +1746,58 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
     // Enable/disable run-time debug level
     if (meshSubDict.found("debug") || mandatory_)
     {
-        // Look for a processor-specific debug flag
-        if (Pstream::parRun() && meshSubDict.found("parDebugProcs"))
+        // Set an attachment point for debugging
+        if
+        (
+            !reRead &&
+            meshSubDict.found("parDebugAttach") &&
+            readBool(meshSubDict.lookup("parDebugAttach"))
+        )
         {
-            labelList procs(meshSubDict.lookup("parDebugProcs"));
+            label wait;
 
-            forAll(procs, procI)
+            if (Pstream::master())
             {
-                if (Pstream::myProcNo() == procs[procI])
+                Info<< nl << "Waiting for debugger attachment..." << endl;
+
+                cin >> wait;
+
+                if (Pstream::parRun())
                 {
-                    debug = readLabel(meshSubDict.lookup("debug"));
+                    for (label i = 1; i < Pstream::nProcs(); i++)
+                    {
+                        meshOps::pWrite(i, wait);
+                    }
+                }
+            }
+            else
+            {
+                meshOps::pRead(Pstream::masterNo(), wait);
+            }
+        }
+
+        // Look for a processor-specific debug flag
+        if
+        (
+            Pstream::parRun() &&
+            meshSubDict.found("parDebugProcs")
+        )
+        {
+            if (!reRead)
+            {
+                labelList procs(meshSubDict.lookup("parDebugProcs"));
+                label pdebug = readLabel(meshSubDict.lookup("debug"));
+
+                if (findIndex(procs, Pstream::myProcNo()) > -1)
+                {
+                    debug = pdebug;
+                }
+                else
+                if (pdebug)
+                {
+                    // Minimal debug information,
+                    // so that synchronizations are successful
+                    debug = 1;
                 }
             }
         }
@@ -1840,7 +1884,7 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
     }
 
     // For tetrahedral meshes...
-    if (!twoDMesh_)
+    if (is3D())
     {
         // Check if swapping is to be avoided on any patches
         if (meshSubDict.found("noSwapPatches") || mandatory_)
@@ -1892,8 +1936,14 @@ void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
     // Check for load-balancing in parallel
     if (reRead && (meshSubDict.found("loadBalancing") || mandatory_))
     {
+        // Fetch non-const reference
+        dictionary& balanceDict =
+        (
+            dict_.subDict("dynamicTopoFvMesh").subDict("loadBalancing")
+        );
+
         // Execute balancing
-        executeLoadBalancing(meshSubDict.subDict("loadBalancing"));
+        executeLoadBalancing(balanceDict);
     }
 }
 
@@ -1921,7 +1971,7 @@ void dynamicTopoFvMesh::initEdges()
     edgeFaces_ = eMeshPtr_->edgeFaces();
     faceEdges_ = eMeshPtr_->faceEdges();
 
-    if (!twoDMesh_)
+    if (is3D())
     {
         // Invert edges to obtain pointEdges
         pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
@@ -1938,7 +1988,7 @@ void dynamicTopoFvMesh::initEdges()
 // Load the mesh-quality metric from the library
 void dynamicTopoFvMesh::loadMetric()
 {
-    if (twoDMesh_)
+    if (is2D())
     {
         return;
     }
@@ -2169,7 +2219,7 @@ void dynamicTopoFvMesh::swap2DEdges(void *argument)
                 );
 
                 Info<< "  Swap Progress: " << percent << "% :"
-                    << "  Total: " << mesh.status(1)
+                    << "  Total: " << mesh.status(TOTAL_SWAPS)
                     << "             \r"
                     << flush;
 
@@ -2206,7 +2256,7 @@ void dynamicTopoFvMesh::swap2DEdges(void *argument)
     if (reported)
     {
         Info<< "  Swap Progress: 100% :"
-            << "  Total: " << mesh.status(1)
+            << "  Total: " << mesh.status(TOTAL_SWAPS)
             << "             \r"
             << endl;
     }
@@ -2275,8 +2325,8 @@ void dynamicTopoFvMesh::swap3DEdges
                 );
 
                 Info<< "  Swap Progress: " << percent << "% :"
-                    << "  Surface: " << mesh.status(2)
-                    << ", Total: " << mesh.status(1)
+                    << "  Surface: " << mesh.status(SURFACE_SWAPS)
+                    << ", Total: " << mesh.status(TOTAL_SWAPS)
                     << "             \r"
                     << flush;
 
@@ -2333,8 +2383,8 @@ void dynamicTopoFvMesh::swap3DEdges
     if (reported)
     {
         Info<< "  Swap Progress: 100% :"
-            << "  Surface: " << mesh.status(2)
-            << ", Total: " << mesh.status(1)
+            << "  Surface: " << mesh.status(SURFACE_SWAPS)
+            << ", Total: " << mesh.status(TOTAL_SWAPS)
             << "             \r"
             << endl;
     }
@@ -2395,9 +2445,9 @@ void dynamicTopoFvMesh::edgeRefinementEngine
                 );
 
                 Info<< "  Refinement Progress: " << percent << "% :"
-                    << "  Bisections: " << mesh.status(3)
-                    << ", Collapses: " << mesh.status(4)
-                    << ", Total: " << mesh.status(0)
+                    << "  Bisections: " << mesh.status(TOTAL_BISECTIONS)
+                    << ", Collapses: " << mesh.status(TOTAL_COLLAPSES)
+                    << ", Total: " << mesh.status(TOTAL_MODIFICATIONS)
                     << "             \r"
                     << flush;
 
@@ -2445,9 +2495,9 @@ void dynamicTopoFvMesh::edgeRefinementEngine
     if (reported)
     {
         Info<< "  Refinement Progress: 100% :"
-            << "  Bisections: " << mesh.status(3)
-            << ", Collapses: " << mesh.status(4)
-            << ", Total: " << mesh.status(0)
+            << "  Bisections: " << mesh.status(TOTAL_BISECTIONS)
+            << ", Collapses: " << mesh.status(TOTAL_COLLAPSES)
+            << ", Total: " << mesh.status(TOTAL_MODIFICATIONS)
             << "             \r"
             << endl;
     }
@@ -2620,7 +2670,7 @@ void dynamicTopoFvMesh::remove2DSlivers()
         {
             if (collapseQuadFace(firstFace).type() > 0)
             {
-                statistics_[7]++;
+                status(TOTAL_SLIVERS)++;
             }
 
             continue;
@@ -2630,7 +2680,7 @@ void dynamicTopoFvMesh::remove2DSlivers()
         {
             if (collapseQuadFace(secondFace).type() > 0)
             {
-                statistics_[7]++;
+                status(TOTAL_SLIVERS)++;
             }
 
             continue;
@@ -2654,7 +2704,7 @@ void dynamicTopoFvMesh::remove2DSlivers()
                 {
                     if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
-                        statistics_[7]++;
+                        status(TOTAL_SLIVERS)++;
                     }
 
                     break;
@@ -2682,7 +2732,7 @@ void dynamicTopoFvMesh::remove2DSlivers()
                 {
                     if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
-                        statistics_[7]++;
+                        status(TOTAL_SLIVERS)++;
                     }
 
                     break;
@@ -2710,7 +2760,7 @@ void dynamicTopoFvMesh::remove2DSlivers()
                 {
                     if (collapseQuadFace(aF[faceI].index()).type() > 0)
                     {
-                        statistics_[7]++;
+                        status(TOTAL_SLIVERS)++;
                     }
 
                     break;
@@ -3125,7 +3175,7 @@ void dynamicTopoFvMesh::removeSlivers()
     }
 
     // Invoke the 2D sliver removal routine
-    if (twoDMesh_)
+    if (is2D())
     {
         remove2DSlivers();
         return;
@@ -3185,7 +3235,7 @@ void dynamicTopoFvMesh::removeSlivers()
             {
                 label proc = procIndices_[procI];
 
-                if (proc < Pstream::myProcNo())
+                if (priority(proc, lessOp<label>(), Pstream::myProcNo()))
                 {
                     Map<label>& rCellMap =
                     (
@@ -3334,13 +3384,13 @@ void dynamicTopoFvMesh::removeSlivers()
             case 2:
             {
                 // Cap cell.
-                label opposingFace = readLabel(map.lookup("opposingFace"));
+                //label opposingFace = readLabel(map.lookup("opposingFace"));
 
                 // Force trisection of the opposing face.
-                changeMap faceMap =
-                (
-                    trisectFace(opposingFace, false, true)
-                );
+                changeMap faceMap;
+                //(
+                //    trisectFace(opposingFace, false, true)
+                //);
 
                 // Collapse the intermediate edge.
                 // Since we don't know which edge it is, search
@@ -3476,7 +3526,7 @@ void dynamicTopoFvMesh::removeSlivers()
         // Increment the count for successful sliver removal
         if (success)
         {
-            statistics_[7]++;
+            status(TOTAL_SLIVERS)++;
         }
     }
 
@@ -3813,6 +3863,12 @@ scalar dynamicTopoFvMesh::edgeLengthScale
 // MultiThreaded topology modifier
 void dynamicTopoFvMesh::threadedTopoModifier()
 {
+    // Set sizes for the reverse maps
+    reversePointMap_.setSize(nPoints_, -7);
+    reverseEdgeMap_.setSize(nEdges_, -7);
+    reverseFaceMap_.setSize(nFaces_, -7);
+    reverseCellMap_.setSize(nCells_, -7);
+
     // Remove sliver cells first.
     removeSlivers();
 
@@ -3863,7 +3919,7 @@ void dynamicTopoFvMesh::threadedTopoModifier()
     // Execute threads
     if (threader_->multiThreaded())
     {
-        if (twoDMesh_)
+        if (is2D())
         {
             executeThreads(topoSequence, handlerPtr_, &swap2DEdges);
         }
@@ -3874,7 +3930,7 @@ void dynamicTopoFvMesh::threadedTopoModifier()
     }
 
     // Set the master thread to implement modifications
-    if (twoDMesh_)
+    if (is2D())
     {
         swap2DEdges(&(handlerPtr_[0]));
     }
@@ -3901,31 +3957,36 @@ bool dynamicTopoFvMesh::resetMesh()
     // Reduce across processors.
     reduce(topoChangeFlag_, orOp<bool>());
 
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
     if (topoChangeFlag_)
     {
         // Write out statistics
-        if (Pstream::parRun() && debug)
+        if (Pstream::parRun())
         {
-            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 (debug)
+            {
+                Pout<< " Bisections :: Total: " << status(TOTAL_BISECTIONS)
+                    << ", Surface: " << status(SURFACE_BISECTIONS) << nl
+                    << " Collapses  :: Total: " << status(TOTAL_COLLAPSES)
+                    << ", Surface: " << status(SURFACE_COLLAPSES) << nl
+                    << " Swaps      :: Total: " << status(TOTAL_SWAPS)
+                    << ", Surface: " << status(SURFACE_SWAPS) << endl;
+            }
+
+            reduce(statistics_, sumOp<labelList>());
         }
 
-        if (status(7))
+        Info<< " Bisections :: Total: " << status(TOTAL_BISECTIONS)
+            << ", Surface: " << status(SURFACE_BISECTIONS) << nl
+            << " Collapses  :: Total: " << status(TOTAL_COLLAPSES)
+            << ", Surface: " << status(SURFACE_COLLAPSES) << nl
+            << " Swaps      :: Total: " << status(TOTAL_SWAPS)
+            << ", Surface: " << status(SURFACE_SWAPS) << endl;
+
+        if (status(TOTAL_SLIVERS))
         {
-            Pout<< " Slivers    :: " << status(7) << endl;
+            Pout<< " Slivers    :: " << status(TOTAL_SLIVERS) << endl;
         }
 
         // Fetch reference to mapper
@@ -3935,6 +3996,17 @@ bool dynamicTopoFvMesh::resetMesh()
         //  - Must be done prior to field-transfers and mesh reset
         fieldMapper.storeMeshInformation();
 
+        // Obtain the number of patches before
+        // any possible boundary reset
+        label nOldPatches = boundaryMesh().size();
+
+        // If the number of patches have changed
+        // at run-time, reset boundaries first
+        if (nPatches_ != nOldPatches)
+        {
+            resetBoundaries();
+        }
+
         // Set up field-transfers before dealing with mapping
         wordList fieldTypes;
         List<wordList> fieldNames;
@@ -3957,8 +4029,6 @@ bool dynamicTopoFvMesh::resetMesh()
 
         // Determine if mapping is to be skipped
         // Optionally skip mapping for remeshing-only / pre-processing
-        const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
-
         bool skipMapping = false;
 
         if (meshSubDict.found("skipMapping") || mandatory_)
@@ -4052,9 +4122,6 @@ bool dynamicTopoFvMesh::resetMesh()
             << 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(nOldPatches);
 
@@ -4077,13 +4144,6 @@ bool dynamicTopoFvMesh::resetMesh()
             xferMove(cellCentres_)
         );
 
-        // 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
@@ -4276,11 +4336,11 @@ bool dynamicTopoFvMesh::resetMesh()
         // Clear flipFaces
         flipFaces_.clear();
 
-        // Set new sizes for the reverse maps
-        reversePointMap_.setSize(nPoints_, -7);
-        reverseEdgeMap_.setSize(nEdges_, -7);
-        reverseFaceMap_.setSize(nFaces_, -7);
-        reverseCellMap_.setSize(nCells_, -7);
+        // Clear reverse maps
+        reversePointMap_.clear();
+        reverseEdgeMap_.clear();
+        reverseFaceMap_.clear();
+        reverseCellMap_.clear();
 
         // Update "old" information
         nOldPoints_ = nPoints_;
@@ -4303,6 +4363,7 @@ bool dynamicTopoFvMesh::resetMesh()
         if (Pstream::parRun())
         {
             procIndices_.clear();
+            procPriority_.clear();
             sendMeshes_.clear();
             recvMeshes_.clear();
         }
@@ -4349,6 +4410,31 @@ bool dynamicTopoFvMesh::resetMesh()
     // Dump length-scale to disk, if requested.
     calculateLengthScale(true);
 
+    // Optionally check if decomposition is to be written out
+    if
+    (
+        Pstream::parRun() &&
+        time().outputTime() &&
+        meshSubDict.found("writeDecomposition") &&
+        readBool(meshSubDict.lookup("writeDecomposition"))
+    )
+    {
+        volScalarField
+        (
+            IOobject
+            (
+                "decomposition",
+                time().timeName(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            *this,
+            dimensionedScalar("rank", dimless, Pstream::myProcNo())
+        ).write();
+    }
+
     // Reset and return flag
     if (topoChangeFlag_)
     {
@@ -4361,6 +4447,26 @@ bool dynamicTopoFvMesh::resetMesh()
 }
 
 
+// Return custom lduAddressing
+const lduAddressing& dynamicTopoFvMesh::lduAddr() const
+{
+    // For subMeshes, avoid globalData construction
+    // due to lduAddressing::patchSchedule, using a
+    // customized approach.
+    if (isSubMesh_)
+    {
+        if (!lduPtr_)
+        {
+            lduPtr_ = new subMeshLduAddressing(*this);
+        }
+
+        return *lduPtr_;
+    }
+
+    return fvMesh::lduAddr();
+}
+
+
 // Update mesh corresponding to the given map
 void dynamicTopoFvMesh::updateMesh(const mapPolyMesh& mpm)
 {
@@ -4375,14 +4481,8 @@ void dynamicTopoFvMesh::updateMesh(const mapPolyMesh& mpm)
     // Delete oldPoints in polyMesh
     polyMesh::resetMotion();
 
-    // Clear-out fvMesh geometry and addressing
-    fvMesh::clearOut();
-
-    // Update polyMesh.
-    polyMesh::updateMesh(mpm);
-
-    // Map all fields
-    mapFields(mpm);
+    // Update fvMesh and polyMesh, and map all fields
+    fvMesh::updateMesh(mpm);
 }
 
 
@@ -4409,6 +4509,10 @@ void dynamicTopoFvMesh::mapFields(const mapPolyMesh& mpm) const
     // Set the mapPolyMesh object in the mapper
     fieldMapper.setMapper(mpm);
 
+    // Deregister gradient fields and centres,
+    // but retain for mapping
+    fieldMapper.deregisterMeshInformation();
+
     // Conservatively map scalar/vector volFields
     conservativeMapVolFields<scalar>(fieldMapper);
     conservativeMapVolFields<vector>(fieldMapper);
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
index 4365e0079..065c622cd 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
@@ -65,10 +65,13 @@ class eMesh;
 class Stack;
 class changeMap;
 class objectMap;
-class coupledInfo;
 class motionSolver;
 class convexSetAlgorithm;
 class lengthScaleEstimator;
+class subMeshLduAddressing;
+
+template <class MeshType>
+class coupledInfo;
 
 /*---------------------------------------------------------------------------*\
                       Class dynamicTopoFvMesh Declaration
@@ -78,6 +81,26 @@ class dynamicTopoFvMesh
 :
     public dynamicFvMesh
 {
+    // Private typedefs
+
+        typedef coupledInfo<dynamicTopoFvMesh> coupledMesh;
+        typedef threadHandler<dynamicTopoFvMesh> meshHandler;
+
+    // Private enumerants
+
+        enum opType
+        {
+            TOTAL_MODIFICATIONS = 0,
+            TOTAL_SWAPS         = 1,
+            TOTAL_BISECTIONS    = 2,
+            TOTAL_COLLAPSES     = 3,
+            SURFACE_SWAPS       = 4,
+            SURFACE_BISECTIONS  = 5,
+            SURFACE_COLLAPSES   = 6,
+            TOTAL_SLIVERS       = 7,
+            TOTAL_OP_TYPES
+        };
+
     // Private data
 
         //- Reference to base mesh
@@ -90,7 +113,7 @@ class dynamicTopoFvMesh
         bool topoChangeFlag_;
 
         //- Is this a subMesh?
-        bool isSubMesh_;
+        Switch isSubMesh_;
 
         //- Dynamic mesh dictionary
         IOdictionary dict_;
@@ -100,7 +123,7 @@ class dynamicTopoFvMesh
         Switch mandatory_;
 
         //- Mesh characteristics [2D/3D]
-        Switch twoDMesh_;
+        bool twoDMesh_;
 
         //- Edge refinement switch
         Switch edgeRefinement_;
@@ -114,6 +137,9 @@ class dynamicTopoFvMesh
         //- Coupled modification switch
         mutable Switch coupledModification_;
 
+        //- Sub-Mesh lduAddressing
+        mutable subMeshLduAddressing* lduPtr_;
+
         //- Specify the re-meshing interval
         label interval_;
 
@@ -218,7 +244,7 @@ class dynamicTopoFvMesh
 
         //- Run-time statistics
         label maxModifications_;
-        FixedList<label, 8> statistics_;
+        labelList statistics_;
 
         //- Sliver exudation
         scalar sliverThreshold_;
@@ -240,8 +266,6 @@ class dynamicTopoFvMesh
         autoPtr<IOmultiThreader> threader_;
 
         // Pointer-list of thread-handlers
-        typedef threadHandler<dynamicTopoFvMesh> meshHandler;
-
         PtrList<meshHandler> handlerPtr_;
 
         // Entity mutexes used for synchronization
@@ -249,14 +273,17 @@ class dynamicTopoFvMesh
         FixedList<Mutex, 4> entityMutex_;
 
         // Local coupled patch information
-        PtrList<coupledInfo> patchCoupling_;
+        PtrList<coupledMesh> patchCoupling_;
 
         // List of processors that this sub-domain talks to
         labelList procIndices_;
 
+        // Processor priority list
+        labelList procPriority_;
+
         // Sub-Mesh pointers
-        PtrList<coupledInfo> sendMeshes_;
-        PtrList<coupledInfo> recvMeshes_;
+        PtrList<coupledMesh> sendMeshes_;
+        PtrList<coupledMesh> recvMeshes_;
 
     // Private Member Functions
 
@@ -334,6 +361,12 @@ class dynamicTopoFvMesh
         // Initialize the threading environment
         void initializeThreadingEnvironment(const label specThreads = -1);
 
+        // Return if mesh is 2D
+        inline bool is2D() const;
+
+        // Return if mesh is 3D
+        inline bool is3D() const;
+
         // Return a non-const reference to the lengthScaleEstimator
         inline lengthScaleEstimator& lengthEstimator();
 
@@ -409,8 +442,8 @@ class dynamicTopoFvMesh
         // Method to determine the boundary patch index for a given edge
         inline label whichEdgePatch(const label index) const;
 
-        // Report topo-modification status
-        inline label status(const label type) const;
+        // Report or alter topo-modification status
+        inline label& status(const label type);
 
         // Method for the swapping of a quad-face in 2D
         const changeMap
@@ -448,15 +481,6 @@ class dynamicTopoFvMesh
             bool forceOp = false
         );
 
-        // Method for the trisection of a face in 3D
-        const changeMap
-        trisectFace
-        (
-            const label fIndex,
-            bool checkOnly = false,
-            bool forceOp = false
-        );
-
         // Method for the collapse of an edge in 3D
         const changeMap
         collapseEdge
@@ -560,6 +584,7 @@ class dynamicTopoFvMesh
             const face& newFace,
             const label newOwner,
             const label newNeighbour,
+            const labelList& newFaceEdges,
             const label zoneID = -1
         );
 
@@ -648,10 +673,6 @@ class dynamicTopoFvMesh
         // around an edge after bisection.
         scalar computeBisectionQuality(const label eIndex) const;
 
-        // Utility method to compute the quality of cells
-        // around a face after trisection.
-        scalar computeTrisectionQuality(const label fIndex) const;
-
         // Check whether the given edge is on a bounding curve
         bool checkBoundingCurve
         (
@@ -945,6 +966,9 @@ class dynamicTopoFvMesh
             PtrList<labelListList>& triangulations
         ) const;
 
+        // Initialize coupled weights calculation
+        void initCoupledWeights();
+
         // Additional mapping contributions for coupled entities
         void computeCoupledWeights
         (
@@ -986,7 +1010,7 @@ class dynamicTopoFvMesh
         void readOptionalParameters(bool reRead = false);
 
         // Execute load balancing operations on the mesh
-        void executeLoadBalancing(const dictionary& balanceDict);
+        void executeLoadBalancing(dictionary& balanceDict);
 
         // Identify coupled patches.
         bool identifyCoupledPatches();
@@ -1035,7 +1059,7 @@ class dynamicTopoFvMesh
         // Build patch sub-mesh for a specified processor
         void buildProcessorPatchMesh
         (
-            coupledInfo& subMesh,
+            coupledMesh& subMesh,
             Map<labelList>& commonCells
         );
 
@@ -1089,13 +1113,25 @@ class dynamicTopoFvMesh
             labelListList& rotations
         ) const;
 
+        // Set processor rank priority
+        void initProcessorPriority();
+
+        // Check for processor priority
+        template <class BinaryOp>
+        inline bool priority
+        (
+            const label first,
+            const BinaryOp& bop,
+            const label second
+        ) const;
+
         // Dump cell-quality statistics
         bool meshQuality(bool outputOption);
 
 public:
 
-    // Declare the name of the class and its debug switch
-        TypeName("dynamicTopoFvMesh");
+    //- Runtime type information
+    TypeName("dynamicTopoFvMesh");
 
     // Constructors
 
@@ -1108,14 +1144,17 @@ public:
 
     // Member Functions
 
-        //- Update mesh corresponding to the given map
+        // Return custom lduAddressing
+        virtual const lduAddressing& lduAddr() const;
+
+        // 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& mpm) const;
 
         // Update the mesh for motion / topology changes
-        // Return true if topology changes have occurred
+        //  - Return true if topology changes have occurred
         virtual bool update();
 };
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
index 051721e0e..ef830e67d 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
@@ -57,8 +57,7 @@ bool dynamicTopoFvMesh::meshQuality
     label nCells = 0, minCell = -1;
     scalar maxQuality = -GREAT;
     scalar minQuality =  GREAT;
-    scalar cQuality = 0.0;
-    scalar meanQuality = 0.0;
+    scalar cQuality, meanQuality = 0.0;
 
     // Track slivers
     bool sliversAbsent = true;
@@ -89,7 +88,7 @@ bool dynamicTopoFvMesh::meshQuality
             continue;
         }
 
-        if (twoDMesh_)
+        if (is2D())
         {
             // Assume XY plane here
             vector n = vector(0,0,1);
@@ -198,25 +197,20 @@ bool dynamicTopoFvMesh::meshQuality
     // Output statistics:
     if (outputOption || (debug > 0))
     {
+        if (minQuality < 0.0)
+        {
+            Pout<< nl
+                << " Warning: Minimum cell quality is: " << minQuality
+                << " at cell: " << minCell
+                << endl;
+        }
+
         // Reduce statistics across processors.
         reduce(minQuality, minOp<scalar>());
         reduce(maxQuality, maxOp<scalar>());
         reduce(meanQuality, sumOp<scalar>());
         reduce(nCells, sumOp<label>());
 
-        if (minQuality < 0.0)
-        {
-            WarningIn
-            (
-                "bool dynamicTopoFvMesh::meshQuality"
-                "(bool outputOption)"
-            )
-                << nl
-                << "Minimum cell quality is: " << minQuality
-                << " at cell: " << minCell
-                << endl;
-        }
-
         Info<< nl
             << " ~~~ Mesh Quality Statistics ~~~ " << nl
             << " Min: " << minQuality << nl
@@ -600,8 +594,7 @@ bool dynamicTopoFvMesh::checkTriangulationVolumes
 ) const
 {
     label m = hullVertices.size();
-    scalar oldTetVol = 0.0;
-    scalar newTetVol = 0.0;
+    scalar oldTetVol = 0.0, newTetVol = 0.0;
 
     const edge& edgeToCheck = edges_[eIndex];
 
@@ -723,7 +716,7 @@ void dynamicTopoFvMesh::writeEdgeConnectivity
     {
         label pIdx = whichPatch(eFaces[faceI]);
 
-        word pName((pIdx < 0) ?	"Internal" : boundaryMesh()[pIdx].name());
+        word pName((pIdx < 0) ? "Internal" : boundaryMesh()[pIdx].name());
 
         Pout<< " Face: " << eFaces[faceI]
             << " :: " << faces_[eFaces[faceI]]
@@ -760,7 +753,7 @@ void dynamicTopoFvMesh::writeEdgeConnectivity
         3, false, true
     );
 
-    if (twoDMesh_)
+    if (is2D())
     {
         return;
     }
@@ -1132,6 +1125,25 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if (curFace.empty())
         {
+            // This might be a deleted face
+            if (faceI < nOldFaces_)
+            {
+                if (reverseFaceMap_[faceI] == -1)
+                {
+                    continue;
+                }
+            }
+            else
+            if (deletedFaces_.found(faceI))
+            {
+                continue;
+            }
+
+            Pout<< "Face " << faceI
+                << " has no vertex labels."
+                << endl;
+
+            nFailedChecks++;
             continue;
         }
 
@@ -1196,7 +1208,7 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
             if (nCommon != 1)
             {
-                Pout<< "Cells: " << nl
+                Pout<< "Cells for face: " << faceI << "::" << curFace << nl
                     << '\t' << owner_[faceI] << ":: " << ownCell << nl
                     << '\t' << neighbour_[faceI] << " :: " << neiCell << nl
                     << " share multiple faces. "
@@ -1691,7 +1703,7 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
         }
     }
 
-    if (!twoDMesh_)
+    if (is3D())
     {
         Pout<< "Checking point-edge connectivity...";
 
@@ -1818,8 +1830,8 @@ void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
 
         if
         (
-            (cellToNode[cellI].size() != 6 && twoDMesh_) ||
-            (cellToNode[cellI].size() != 4 && !twoDMesh_)
+            (cellToNode[cellI].size() != 6 && is2D()) ||
+            (cellToNode[cellI].size() != 4 && is3D())
         )
         {
             Pout<< nl << "Warning: Cell: "
@@ -2183,9 +2195,7 @@ bool dynamicTopoFvMesh::checkCollapse
 ) const
 {
     label faceIndex = -1;
-    scalar cQuality = 0;
-    scalar oldVolume = 0;
-    scalar newVolume = 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'
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
index 75cfab51f..6c211b406 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
@@ -47,6 +47,20 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+// Return if mesh is 2D
+inline bool dynamicTopoFvMesh::is2D() const
+{
+    return twoDMesh_;
+}
+
+
+// Return if mesh is 3D
+inline bool dynamicTopoFvMesh::is3D() const
+{
+    return !twoDMesh_;
+}
+
+
 // Return a non-const reference to the lengthScaleEstimator
 inline lengthScaleEstimator&
 dynamicTopoFvMesh::lengthEstimator()
@@ -121,7 +135,7 @@ inline label dynamicTopoFvMesh::getEdgeIndex
     const edge& edgeToCheck
 ) const
 {
-    if (twoDMesh_)
+    if (is2D())
     {
         // No efficient search method. Loop through all edges.
         forAll(edges_, edgeI)
@@ -206,7 +220,7 @@ inline bool dynamicTopoFvMesh::checkBisection
 {
     scalar length = 0.0, scale = 0.0;
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // If this entity was deleted, skip it.
         if (faces_[index].empty())
@@ -274,7 +288,7 @@ inline bool dynamicTopoFvMesh::checkCollapse
 {
     scalar length = 0.0, scale = 0.0;
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // If this entity was deleted, skip it.
         if (faces_[index].empty())
@@ -390,7 +404,7 @@ inline void dynamicTopoFvMesh::initStacks
         tID = 0;
     }
 
-    if (twoDMesh_)
+    if (is2D())
     {
         forAll(faces_, faceI)
         {
@@ -447,7 +461,7 @@ inline void dynamicTopoFvMesh::initStacks
                 stackElements[elemI] = stack(0)[elemI];
             }
 
-            label elemType = twoDMesh_ ? 2 : 1;
+            label elemType = is2D() ? 2 : 1;
 
             writeVTK
             (
@@ -568,34 +582,20 @@ inline label dynamicTopoFvMesh::whichEdgePatch
 }
 
 
-// Report topo-modification status
-//  - Enumerants are as follows
-//    [0] nModifications
-//    [1] Total swaps (internal and surface)
-//    [2] Surface swaps
-//    [3] Total bisections
-//    [4] Total collapses
-//    [5] Surface bisections
-//    [6] Surface collapses
-//    [7] Slivers removed
-inline label dynamicTopoFvMesh::status(const label type) const
+// Report or alter topo-modification status
+inline label& dynamicTopoFvMesh::status(const label type)
 {
-    if (type < statistics_.size())
-    {
-        return statistics_[type];
-    }
-    else
+    if (type < 0 || type >= TOTAL_OP_TYPES)
     {
         FatalErrorIn
         (
-            "inline label dynamicTopoFvMesh::status"
-            "(const label type) const"
+            "inline label& dynamicTopoFvMesh::status(const label type)"
         )
             << " Unknown type: " << type << nl
             << abort(FatalError);
     }
 
-    return 0;
+    return statistics_[type];
 }
 
 
@@ -618,6 +618,19 @@ inline void dynamicTopoFvMesh::setFlip(const label fIndex)
 }
 
 
+// Check for processor priority
+template <class BinaryOp>
+inline bool dynamicTopoFvMesh::priority
+(
+    const label first,
+    const BinaryOp& bop,
+    const label second
+) const
+{
+    return bop(procPriority_[first], procPriority_[second]);
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
index 00a5f73fd..12b61cfa1 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
@@ -131,7 +131,7 @@ void dynamicTopoFvMesh::computeMapping
                 // for mild convexity.
                 const cell& cellToCheck = cells_[cIndex];
 
-                if (twoDMesh_)
+                if (is2D())
                 {
                     const labelList& parents = cellParents_[cIndex];
 
@@ -603,6 +603,9 @@ void dynamicTopoFvMesh::threadedMapping
         boundary[patchI].faceFaces();
     }
 
+    // Force calculation of demand-driven data on subMeshes
+    initCoupledWeights();
+
     // Execute threads in linear sequence
     executeThreads(identity(nThreads), hdl, &computeMappingThread);
 }
@@ -668,7 +671,7 @@ void dynamicTopoFvMesh::setCellMapping
                 masterCells.append(mapCells[cellI]);
             }
         }
-        else
+
         if (cellParents_.found(mapCells[cellI]))
         {
             const labelList& nParents = cellParents_[mapCells[cellI]];
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
index 69b2bd2c8..f1afec261 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
@@ -24,7 +24,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "objectMap.H"
-#include "objectRegistry.H"
 #include "coupledInfo.H"
 #include "dynamicTopoFvMesh.H"
 
@@ -119,10 +118,6 @@ void dynamicTopoFvMesh::reOrderPoints
             << abort(FatalError);
     }
 
-    // Wipe out pointsFromPoints, since this is not
-    // really used in this context for mapping.
-    pointsFromPoints_.clear();
-
     // Renumber all maps.
     forAll(pointsFromPoints_, indexI)
     {
@@ -534,7 +529,7 @@ void dynamicTopoFvMesh::reOrderEdges
         entityMutex_[2].unlock();
     }
 
-    if (!twoDMesh_)
+    if (is3D())
     {
         // Invert edges to obtain pointEdges
         pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
@@ -1725,7 +1720,30 @@ void dynamicTopoFvMesh::reOrderMesh
 {
     if (debug)
     {
-        Info<< nl
+        // Buffered print-out of mesh-stats
+        if (Pstream::parRun())
+        {
+            if (Pstream::master())
+            {
+                for (label i = Pstream::nProcs() - 1; i >= 1; i--)
+                {
+                    // Notify slave
+                    meshOps::pWrite(i, i);
+
+                    // Wait for response from slave
+                    label j = 0;
+                    meshOps::pRead(i, j);
+                }
+            }
+            else
+            {
+                // Wait for master
+                label i = 0;
+                meshOps::pRead(Pstream::masterNo(), i);
+            }
+        }
+
+        Pout<< nl
             << "=================" << nl
             << " Mesh reOrdering " << nl
             << "=================" << nl
@@ -1740,13 +1758,13 @@ void dynamicTopoFvMesh::reOrderMesh
 
         if (debug > 1)
         {
-            Info<< " Patch Starts [Face]: " << oldPatchStarts_ << nl
+            Pout<< " Patch Starts [Face]: " << oldPatchStarts_ << nl
                 << " Patch Sizes  [Face]: " << oldPatchSizes_ << nl
                 << " Patch Starts [Edge]: " << oldEdgePatchStarts_ << nl
                 << " Patch Sizes  [Edge]: " << oldEdgePatchSizes_ << nl;
         }
 
-        Info<< "=================" << nl
+        Pout<< "=================" << nl
             << " Mesh Info [n+1]:" << nl
             << " Points: " << nPoints_ << nl
             << " Edges: " << nEdges_ << nl
@@ -1758,13 +1776,22 @@ void dynamicTopoFvMesh::reOrderMesh
 
         if (debug > 1)
         {
-            Info<< " Patch Starts [Face]: " << patchStarts_ << nl
+            Pout<< " Patch Starts [Face]: " << patchStarts_ << nl
                 << " Patch Sizes: [Face]: " << patchSizes_ << nl
                 << " Patch Starts [Edge]: " << edgePatchStarts_ << nl
                 << " Patch Sizes: [Edge]: " << edgePatchSizes_ << nl;
         }
 
-        Info<< "=================" << endl;
+        Pout<< "=================" << endl;
+
+        // Notify master
+        if (Pstream::parRun() && !Pstream::master())
+        {
+            meshOps::pWrite(Pstream::masterNo(), Pstream::myProcNo());
+        }
+
+        bool checkPoint = false;
+        reduce(checkPoint, andOp<bool>());
 
         // Check connectivity structures for consistency
         // before entering the reOrdering phase.
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
index 95cdc4881..a351e7bdf 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
@@ -63,8 +63,6 @@ void eMesh::clearAddressing() const
 
     edges_.clear();
 
-    deleteDemandDrivenData(pePtr_);
-    deleteDemandDrivenData(epPtr_);
     deleteDemandDrivenData(fePtr_);
     deleteDemandDrivenData(efPtr_);
 }
@@ -147,8 +145,6 @@ eMesh::eMesh(const polyMesh& pMesh, const word& subDir)
         ),
         *this
     ),
-    pePtr_(NULL),
-    epPtr_(NULL),
     fePtr_(NULL),
     efPtr_(NULL)
 {
@@ -391,28 +387,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 c1d8c53d3..e7017ce62 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
@@ -35,7 +35,6 @@ SourceFiles
 #ifndef eMesh_H
 #define eMesh_H
 
-#include "objectRegistry.H"
 #include "Time.H"
 #include "polyMesh.H"
 #include "edgeIOList.H"
@@ -80,12 +79,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 +104,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 +184,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 6b301ab00..f9e94959b 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
@@ -145,201 +145,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);
-            }
-#           else
-            // dummy statement to quech compiler warning
-            found = found;
-#           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 9d9e15f01..fde98b136 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
@@ -79,6 +79,8 @@ ePatch::ePatch
     size_(readLabel(dict.lookup("size")))
 {}
 
+
+//- Construct as copy, resetting the boundary mesh
 ePatch::ePatch(const ePatch& p, const eBoundaryMesh& bm)
 :
     patchIdentifier(p, p.index()),
@@ -88,6 +90,16 @@ ePatch::ePatch(const ePatch& p, const eBoundaryMesh& bm)
 {}
 
 
+//- Construct as copy
+ePatch::ePatch(const ePatch& p)
+:
+    patchIdentifier(p),
+    boundaryMesh_(p.boundaryMesh_),
+    start_(p.start_),
+    size_(p.size_)
+{}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 ePatch::~ePatch()
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
index ff4bb264f..86d770a16 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
@@ -68,14 +68,6 @@ private:
         //- Size of the patch
         label size_;
 
-        // Demand-driven private data
-
-
-    // Private Member Functions
-
-        //- Disallow construct as copy
-        ePatch(const ePatch&);
-
 protected:
 
         // The ePatch geometry initialisation is called by eBoundaryMesh
@@ -159,7 +151,6 @@ public:
             const eBoundaryMesh& bm
         );
 
-
         //- Construct from dictionary
         ePatch
         (
@@ -172,6 +163,9 @@ public:
         //- Construct as copy, resetting the boundary mesh
         ePatch(const ePatch&, const eBoundaryMesh&);
 
+        //- Construct as copy
+        ePatch(const ePatch&);
+
 
     // Selectors
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C
index 436f53ea0..ad49d7b03 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C
@@ -65,7 +65,7 @@ autoPtr<ePatch> ePatch::New
         )   << "Unknown ePatch type " << patchType << " for patch " << name
             << endl << endl
             << "Valid ePatch types are :" << endl
-            << wordConstructorTablePtr_->sortedToc()
+            << wordConstructorTablePtr_->toc()
             << exit(FatalError);
     }
 
@@ -102,7 +102,7 @@ autoPtr<ePatch> ePatch::New
             dict
         )   << "Unknown ePatch type " << patchType << endl << endl
             << "Valid ePatch types are :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
+            << dictionaryConstructorTablePtr_->toc()
             << exit(FatalIOError);
     }
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
index be1f8c87d..e0f2b9158 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
@@ -24,12 +24,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "Stack.H"
-#include "objectRegistry.H"
 #include "triFace.H"
 #include "objectMap.H"
 #include "changeMap.H"
-#include "multiThreader.H"
 #include "coupledInfo.H"
+#include "multiThreader.H"
 #include "dynamicTopoFvMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -71,7 +70,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
     if
     (
-        (statistics_[0] > maxModifications_) &&
+        (status(TOTAL_MODIFICATIONS) > maxModifications_) &&
         (maxModifications_ > -1)
     )
     {
@@ -306,7 +305,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             forAll(procIndices_, pI)
             {
                 // Fetch reference to subMesh
-                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupledMesh& recvMesh = recvMeshes_[pI];
                 const coupleMap& cMap = recvMesh.map();
 
                 label sIndex = -1;
@@ -323,7 +322,15 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
                     // Check if a lower-ranked processor is
                     // handling this edge
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                         if (debug > 3)
                         {
@@ -398,7 +405,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         {
             cMapPtr = &(recvMeshes_[pI].map());
 
-            coupledInfo& recvMesh = recvMeshes_[pI];
+            coupledMesh& recvMesh = recvMeshes_[pI];
 
             // First check the slave for bisection feasibility.
             slaveMap =
@@ -480,7 +487,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         }
         else
         {
-            coupledInfo& recvMesh = recvMeshes_[pI];
+            coupledMesh& recvMesh = recvMeshes_[pI];
 
             // Bisect the slave face
             slaveMap =
@@ -541,7 +548,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
 
         if (debug > 2)
         {
-            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " On SubMesh: " << isSubMesh_ << nl;
             Pout<< " coupledModification: " << coupledModification_ << nl;
 
             const polyBoundaryMesh& boundary = boundaryMesh();
@@ -900,13 +907,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             -1,
             tmpQuadFace,
             c0,
-            newCellIndex[0]
+            newCellIndex[0],
+            tmpQFEdges
         )
     );
 
-    // Add a faceEdges entry as well
-    faceEdges_.append(tmpQFEdges);
-
     // Add this face to the map.
     map.addFace(newFaceIndex[0]);
 
@@ -952,13 +957,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             whichPatch(c0BdyIndex[0]),
             tmpTriFace,
             newCellIndex[0],
-            -1
+            -1,
+            tmpTFEdges
         )
     );
 
-    // Add a faceEdges entry as well
-    faceEdges_.append(tmpTFEdges);
-
     // Add this face to the map.
     map.addFace(newFaceIndex[1]);
 
@@ -981,13 +984,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
             whichPatch(c0BdyIndex[1]),
             tmpTriFace,
             c0,
-            -1
+            -1,
+            tmpTFEdges
         )
     );
 
-    // Add a faceEdges entry as well
-    faceEdges_.append(tmpTFEdges);
-
     // Add this face to the map.
     map.addFace(newFaceIndex[2]);
 
@@ -1101,13 +1102,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
                 whichPatch(fIndex),
                 tmpQuadFace,
                 newCellIndex[0],
-                -1
+                -1,
+                tmpQFEdges
             )
         );
 
-        // Add a faceEdges entry as well
-        faceEdges_.append(tmpQFEdges);
-
         // Add this face to the map.
         map.addFace(newFaceIndex[3]);
 
@@ -1393,13 +1392,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
                 -1,
                 tmpQuadFace,
                 newCellIndex[0],
-                newCellIndex[1]
+                newCellIndex[1],
+                tmpQFEdges
             )
         );
 
-        // Add a faceEdges entry as well
-        faceEdges_.append(tmpQFEdges);
-
         // Add this face to the map.
         map.addFace(newFaceIndex[3]);
 
@@ -1546,13 +1543,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
                 -1,
                 tmpQuadFace,
                 c1,
-                newCellIndex[1]
+                newCellIndex[1],
+                tmpQFEdges
             )
         );
 
-        // Add a faceEdges entry as well
-        faceEdges_.append(tmpQFEdges);
-
         // Add this face to the map.
         map.addFace(newFaceIndex[4]);
 
@@ -1598,13 +1593,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
                 whichPatch(commonFaceIndex[2]),
                 tmpTriFace,
                 c1,
-                -1
+                -1,
+                tmpTFEdges
             )
         );
 
-        // Add a faceEdges entry as well
-        faceEdges_.append(tmpTFEdges);
-
         // Add this face to the map.
         map.addFace(newFaceIndex[5]);
 
@@ -1627,13 +1620,11 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
                 whichPatch(commonFaceIndex[3]),
                 tmpTriFace,
                 newCellIndex[1],
-                -1
+                -1,
+                tmpTFEdges
             )
         );
 
-        // Add a faceEdges entry as well
-        faceEdges_.append(tmpTFEdges);
-
         // Add this face to the map.
         map.addFace(newFaceIndex[6]);
 
@@ -2341,7 +2332,7 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
     topoChangeFlag_ = true;
 
     // Increment the counter
-    statistics_[3]++;
+    status(TOTAL_BISECTIONS)++;
 
     // Increment surface-counter
     if (c1 == -1)
@@ -2349,12 +2340,12 @@ const changeMap dynamicTopoFvMesh::bisectQuadFace
         // Do not update stats for processor patches
         if (!processorCoupledEntity(fIndex))
         {
-            statistics_[5]++;
+            status(SURFACE_BISECTIONS)++;
         }
     }
 
     // Increment the number of modifications
-    statistics_[0]++;
+    status(TOTAL_MODIFICATIONS)++;
 
     // Specify that the operation was successful
     map.type() = 1;
@@ -2387,7 +2378,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     //      Update faceEdges and edgeFaces information
 
     // For 2D meshes, perform face-bisection
-    if (twoDMesh_)
+    if (is2D())
     {
         return bisectQuadFace(eIndex, changeMap(), checkOnly);
     }
@@ -2402,7 +2393,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
     if
     (
-        (statistics_[0] > maxModifications_) &&
+        (status(TOTAL_MODIFICATIONS) > maxModifications_) &&
         (maxModifications_ > -1)
     )
     {
@@ -2551,15 +2542,23 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             forAll(procIndices_, pI)
             {
                 // Fetch reference to subMeshes
-                const coupledInfo& sendMesh = sendMeshes_[pI];
-                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupledMesh& sendMesh = sendMeshes_[pI];
+                const coupledMesh& 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
+                (
+                    priority
+                    (
+                        procIndices_[pI],
+                        lessOp<label>(),
+                        Pstream::myProcNo()
+                    )
+                )
                 {
                     if (scMap.reverseEntityMap(edgeEnum).found(eIndex))
                     {
@@ -2591,7 +2590,15 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
                     // Check if a lower-ranked processor is
                     // handling this edge
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                         if (debug > 3)
                         {
@@ -2824,7 +2831,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
         // Do not update stats for processor patches
         if (!processorCoupledEntity(eIndex))
         {
-            statistics_[5]++;
+            status(SURFACE_BISECTIONS)++;
         }
     }
 
@@ -2871,7 +2878,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             << ": " << origEdge
             << " is to be bisected. " << endl;
 
-        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " On SubMesh: " << isSubMesh_ << nl;
         Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichEdgePatch(eIndex);
@@ -3024,13 +3031,11 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     -1,
                     tmpTriFace,
                     cellHull[indexI],
-                    addedCellIndices[indexI]
+                    addedCellIndices[indexI],
+                    tmpFaceEdges
                 )
             );
 
-            // Add a faceEdges entry as well
-            faceEdges_.append(tmpFaceEdges);
-
             // Add this face to the map.
             map.addFace(addedIntFaceIndices[indexI]);
 
@@ -3102,7 +3107,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                         whichPatch(faceHull[indexI]),
                         tmpTriFace,
                         addedCellIndices[indexI],
-                        -1
+                        -1,
+                        labelList(3, -1)
                     )
                 );
 
@@ -3156,7 +3162,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 );
 
                 // Add the faceEdges entry
-                faceEdges_.append(tmpFaceEdges);
+                faceEdges_[addedFaceIndices[indexI]] = tmpFaceEdges;
 
                 // Add an entry to edgeFaces
                 edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
@@ -3181,7 +3187,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                         -1,
                         tmpTriFace,
                         addedCellIndices[prevI],
-                        addedCellIndices[indexI]
+                        addedCellIndices[indexI],
+                        labelList(3, -1)
                     )
                 );
 
@@ -3242,7 +3249,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 );
 
                 // Add the faceEdges entry
-                faceEdges_.append(tmpFaceEdges);
+                faceEdges_[addedFaceIndices[indexI]] = tmpFaceEdges;
 
                 // Add an entry to edgeFaces
                 edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
@@ -3270,7 +3277,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                         -1,
                         tmpTriFace,
                         addedCellIndices[0],
-                        addedCellIndices[indexI]
+                        addedCellIndices[indexI],
+                        labelList(3, -1)
                     )
                 );
 
@@ -3331,7 +3339,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 );
 
                 // Add the faceEdges entry
-                faceEdges_.append(tmpFaceEdges);
+                faceEdges_[addedFaceIndices[0]] = tmpFaceEdges;
 
                 // Add an entry to edgeFaces
                 edgeFaces_[newEdgeIndex][0] = addedFaceIndices[0];
@@ -3361,7 +3369,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     whichPatch(faceHull[indexI]),
                     tmpTriFace,
                     addedCellIndices[prevI],
-                    -1
+                    -1,
+                    labelList(3, -1)
                 )
             );
 
@@ -3415,7 +3424,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             );
 
             // Add the faceEdges entry
-            faceEdges_.append(tmpFaceEdges);
+            faceEdges_[addedFaceIndices[indexI]] = tmpFaceEdges;
 
             // Add an entry to edgeFaces
             edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
@@ -3558,6 +3567,10 @@ const changeMap dynamicTopoFvMesh::bisectEdge
             }
         }
 
+        // Prepare a checklist
+        boolList matchedFaces(checkFaces.size(), false);
+        boolList matchedEdges(checkEdges.size(), false);
+
         // Output check entities
         if (debug > 4)
         {
@@ -3704,8 +3717,6 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     continue;
                 }
 
-                bool matchedFace = false;
-
                 // Fetch edges connected to the slave point
                 const labelList& spEdges = sMesh.pointEdges_[slavePoint];
 
@@ -3720,9 +3731,9 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
                     const labelList& seFaces = sMesh.edgeFaces_[seIndex];
 
-                    forAll(seFaces, faceI)
+                    forAll(seFaces, faceJ)
                     {
-                        label sfIndex = seFaces[faceI];
+                        label sfIndex = seFaces[faceJ];
 
                         if (sMesh.whichPatch(sfIndex) == -1)
                         {
@@ -3769,25 +3780,25 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                                 faceMap.insert(mfIndex, sfIndex);
                             }
 
-                            matchedFace = true;
+                            matchedFaces[faceI] = true;
 
                             break;
                         }
                     }
 
-                    if (matchedFace)
+                    if (matchedFaces[faceI])
                     {
                         break;
                     }
                 }
 
-                if (!matchedFace)
+                if ((debug > 4) && !matchedFaces[faceI])
                 {
                     sMesh.writeVTK
                     (
                         "failedFacePoints_"
                       + Foam::name(mfIndex),
-                        cF, 0, false, true
+                        labelList(cF), 0, false, true
                     );
 
                     writeVTK
@@ -3800,7 +3811,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                         << mfIndex << " :: " << mF
                         << " masterPatch: " << mfPatch
                         << " using comparison face: " << cF
-                        << abort(FatalError);
+                        << " on proc: " << procIndices_[pI]
+                        << endl;
                 }
             }
 
@@ -3817,7 +3829,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
 
                 const edge& mE = edges_[meIndex];
 
-                label mePatch = whichPatch(meIndex);
+                label mePatch = whichEdgePatch(meIndex);
                 label neiProc = getNeighbourProcessor(mePatch);
 
                 edge cE
@@ -3832,14 +3844,12 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     continue;
                 }
 
-                bool matchedEdge = false;
-
                 // Fetch edges connected to the slave point
                 const labelList& spEdges = sMesh.pointEdges_[cE[0]];
 
-                forAll(spEdges, edgeI)
+                forAll(spEdges, edgeJ)
                 {
-                    label seIndex = spEdges[edgeI];
+                    label seIndex = spEdges[edgeJ];
 
                     const edge& sE = sMesh.edges_[seIndex];
 
@@ -3851,6 +3861,7 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                                 << " :: " << sE
                                 << " with meIndex: " << meIndex
                                 << " :: " << mE
+                                << " on proc: " << procIndices_[pI]
                                 << endl;
                         }
 
@@ -3874,13 +3885,13 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                             edgeMap.insert(meIndex, seIndex);
                         }
 
-                        matchedEdge = true;
+                        matchedEdges[edgeI] = true;
 
                         break;
                     }
                 }
 
-                if (!matchedEdge)
+                if (!matchedEdges[edgeI])
                 {
                     if (procCouple && !localCouple)
                     {
@@ -3899,18 +3910,18 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                                     << endl;
                             }
 
-                            matchedEdge = true;
+                            matchedEdges[edgeI] = true;
                         }
                     }
                 }
 
-                if (!matchedEdge)
+                if ((debug > 4) && !matchedEdges[edgeI])
                 {
                     sMesh.writeVTK
                     (
                         "failedEdge_"
                       + Foam::name(meIndex),
-                        cE, 0, false, true
+                        labelList(cE), 0, false, true
                     );
 
                     writeVTK
@@ -3922,7 +3933,8 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                     Pout<< " Failed to match edge: "
                         << meIndex << " :: " << mE
                         << " using comparison edge: " << cE
-                        << abort(FatalError);
+                        << " on proc: " << procIndices_[pI]
+                        << endl;
                 }
             }
 
@@ -3936,6 +3948,33 @@ const changeMap dynamicTopoFvMesh::bisectEdge
                 );
             }
         }
+
+        // Ensure that all entities were matched
+        label nFailFace = 0, nFailEdge = 0;
+
+        forAll(matchedFaces, faceI)
+        {
+            if (!matchedFaces[faceI])
+            {
+                ++nFailFace;
+            }
+        }
+
+        forAll(matchedEdges, edgeI)
+        {
+            if (!matchedEdges[edgeI])
+            {
+                ++nFailEdge;
+            }
+        }
+
+        if (nFailFace || nFailEdge)
+        {
+            Pout<< " Failed to match all entities. " << nl
+                << "  Faces: " << nFailFace << nl
+                << "  Edges: " << nFailEdge << nl
+                << abort(FatalError);
+        }
     }
 
     if (debug > 2)
@@ -4088,1687 +4127,10 @@ const changeMap dynamicTopoFvMesh::bisectEdge
     topoChangeFlag_ = true;
 
     // Increment the counter
-    statistics_[3]++;
+    status(TOTAL_BISECTIONS)++;
 
     // Increment the number of modifications
-    statistics_[0]++;
-
-    // Specify that the operation was successful
-    map.type() = 1;
-
-    // Return the changeMap
-    return map;
-}
-
-
-// Method for the trisection of a face in 3D
-// - Returns a changeMap with a type specifying:
-//     1: Trisection was successful
-//    -1: Trisection failed since max number of topo-changes was reached.
-//    -2: Trisection failed since resulting quality would be really bad.
-// - AddedPoint is the index of the newly added point.
-const changeMap dynamicTopoFvMesh::trisectFace
-(
-    const label fIndex,
-    bool checkOnly,
-    bool forceOp
-)
-{
-    // Face trisection performs the following operations:
-    //      [1] Add a point at middle of the face
-    //      [2] Remove the face and add three new faces in place.
-    //      [3] Add three cells for each trisected cell (remove the originals).
-    //      [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 and edgeFaces information.
-
-    // Figure out which thread this is...
-    label tIndex = self(), pIndex = -1;
-
-    // Prepare the changeMaps
-    changeMap map, slaveMap;
-    bool trisectingSlave = false;
-
-    if
-    (
-        (statistics_[0] > maxModifications_) &&
-        (maxModifications_ > -1)
-    )
-    {
-        // Reached the max allowable topo-changes.
-        stack(tIndex).clear();
-
-        return map;
-    }
-
-    // Sanity check: Is the index legitimate?
-    if (fIndex < 0)
-    {
-        FatalErrorIn
-        (
-            "const changeMap dynamicTopoFvMesh::trisectFace\n"
-            "(\n"
-            "    const label fIndex,\n"
-            "    bool checkOnly,\n"
-            "    bool forceOp\n"
-            ")\n"
-        )
-            << " Invalid index: " << fIndex
-            << 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;
-
-    if ((minQ = computeTrisectionQuality(fIndex)) < sliverThreshold_)
-    {
-        // Check if the quality is actually valid before forcing it.
-        if (forceOp && (minQ < 0.0))
-        {
-            FatalErrorIn
-            (
-                "const changeMap dynamicTopoFvMesh::trisectFace\n"
-                "(\n"
-                "    const label fIndex,\n"
-                "    bool checkOnly,\n"
-                "    bool forceOp\n"
-                ")\n"
-            )
-                << " Forcing trisection on face: " << fIndex
-                << " will yield an invalid cell."
-                << abort(FatalError);
-        }
-        else
-        if (!forceOp)
-        {
-            map.type() = -2;
-            return map;
-        }
-    }
-
-    // Are we performing only checks?
-    if (checkOnly)
-    {
-        map.type() = 1;
-        return map;
-    }
-
-    // Update number of surface bisections, if necessary.
-    if (whichPatch(fIndex) > -1)
-    {
-        statistics_[5]++;
-    }
-
-    // Hull variables
-    face tmpTriFace(3);
-    labelList newTriEdgeFaces(3);
-    labelList newQuadEdgeFaces(4);
-
-    FixedList<label,2> apexPoint(-1);
-    FixedList<face, 3> checkFace(face(3));
-    FixedList<label,5> newEdgeIndex(-1);
-    FixedList<label,9> newFaceIndex(-1);
-    FixedList<label,6> newCellIndex(-1);
-    FixedList<cell, 6> newTetCell(cell(4));
-    FixedList<labelList, 9> newFaceEdges(labelList(3));
-
-    // Counters for entities
-    FixedList<label, 9> nE(0);
-    FixedList<label, 6> nF(0);
-
-    // Determine the two cells to be removed
-    FixedList<label,2> cellsForRemoval;
-    cellsForRemoval[0] = owner_[fIndex];
-    cellsForRemoval[1] = neighbour_[fIndex];
-
-    if (debug > 1)
-    {
-        Pout<< nl << nl
-            << "Face: " << fIndex
-            << ": " << faces_[fIndex]
-            << " is to be trisected. " << endl;
-
-        // Write out VTK files prior to change
-        if (debug > 3)
-        {
-            labelList vtkCells;
-
-            if (neighbour_[fIndex] == -1)
-            {
-                vtkCells.setSize(1);
-                vtkCells[0] = owner_[fIndex];
-            }
-            else
-            {
-                vtkCells.setSize(2);
-                vtkCells[0] = owner_[fIndex];
-                vtkCells[1] = neighbour_[fIndex];
-            }
-
-            writeVTK
-            (
-                Foam::name(fIndex)
-              + "Trisect_0",
-                vtkCells
-            );
-        }
-    }
-
-    labelList mP(3, -1);
-
-    // Fill in mapping information
-    mP[0] = faces_[fIndex][0];
-    mP[1] = faces_[fIndex][1];
-    mP[2] = faces_[fIndex][2];
-
-    // Add a new point to the end of the list
-    scalar oT = (1.0/3.0);
-
-    label newPointIndex =
-    (
-        insertPoint
-        (
-            oT * (points_[mP[0]] + points_[mP[1]] + points_[mP[2]]),
-            oT * (oldPoints_[mP[0]] + oldPoints_[mP[1]] + oldPoints_[mP[2]]),
-            mP
-        )
-    );
-
-    // Add this point to the map.
-    map.addPoint(newPointIndex);
-
-    // Add three new cells to the end of the cell list
-    for (label i = 0; i < 3; i++)
-    {
-        scalar parentScale = -1.0;
-
-        if (edgeRefinement_)
-        {
-            parentScale = lengthScale_[cellsForRemoval[0]];
-        }
-
-        newCellIndex[i] = insertCell(newTetCell[i], parentScale);
-
-        // Add cells to the map
-        map.addCell(newCellIndex[i]);
-    }
-
-    // Find the apex point for this cell
-    apexPoint[0] =
-    (
-        meshOps::tetApexPoint
-        (
-            owner_[fIndex],
-            fIndex,
-            faces_,
-            cells_
-        )
-    );
-
-    // Insert three new internal faces
-
-    // First face: Owner: newCellIndex[0], Neighbour: newCellIndex[1]
-    tmpTriFace[0] = newPointIndex;
-    tmpTriFace[1] = faces_[fIndex][0];
-    tmpTriFace[2] = apexPoint[0];
-
-    newFaceIndex[0] =
-    (
-        insertFace
-        (
-            -1,
-            tmpTriFace,
-            newCellIndex[0],
-            newCellIndex[1]
-        )
-    );
-
-    // Second face: Owner: newCellIndex[1], Neighbour: newCellIndex[2]
-    tmpTriFace[0] = newPointIndex;
-    tmpTriFace[1] = faces_[fIndex][1];
-    tmpTriFace[2] = apexPoint[0];
-
-    newFaceIndex[1] =
-    (
-        insertFace
-        (
-            -1,
-            tmpTriFace,
-            newCellIndex[1],
-            newCellIndex[2]
-        )
-    );
-
-    // Third face: Owner: newCellIndex[0], Neighbour: newCellIndex[2]
-    tmpTriFace[0] = newPointIndex;
-    tmpTriFace[1] = apexPoint[0];
-    tmpTriFace[2] = faces_[fIndex][2];
-
-    newFaceIndex[2] =
-    (
-        insertFace
-        (
-            -1,
-            tmpTriFace,
-            newCellIndex[0],
-            newCellIndex[2]
-        )
-    );
-
-    // Add an entry to edgeFaces
-    newTriEdgeFaces[0] = newFaceIndex[0];
-    newTriEdgeFaces[1] = newFaceIndex[1];
-    newTriEdgeFaces[2] = newFaceIndex[2];
-
-    // Add a new internal edge to the mesh
-    newEdgeIndex[0] =
-    (
-        insertEdge
-        (
-            -1,
-            edge
-            (
-               newPointIndex,
-               apexPoint[0]
-            ),
-            newTriEdgeFaces
-        )
-    );
-
-    // Configure faceEdges with the new internal edge
-    newFaceEdges[0][nE[0]++] = newEdgeIndex[0];
-    newFaceEdges[1][nE[1]++] = newEdgeIndex[0];
-    newFaceEdges[2][nE[2]++] = newEdgeIndex[0];
-
-    // Add the newly created faces to cells
-    newTetCell[0][nF[0]++] = newFaceIndex[0];
-    newTetCell[0][nF[0]++] = newFaceIndex[2];
-    newTetCell[1][nF[1]++] = newFaceIndex[0];
-    newTetCell[1][nF[1]++] = newFaceIndex[1];
-    newTetCell[2][nF[2]++] = newFaceIndex[1];
-    newTetCell[2][nF[2]++] = newFaceIndex[2];
-
-    // Define the three faces to check for orientation:
-    checkFace[0][0] = faces_[fIndex][2];
-    checkFace[0][1] = apexPoint[0];
-    checkFace[0][2] = faces_[fIndex][0];
-
-    checkFace[1][0] = faces_[fIndex][0];
-    checkFace[1][1] = apexPoint[0];
-    checkFace[1][2] = faces_[fIndex][1];
-
-    checkFace[2][0] = faces_[fIndex][1];
-    checkFace[2][1] = apexPoint[0];
-    checkFace[2][2] = faces_[fIndex][2];
-
-    // Check the orientation of faces on the first cell.
-    forAll(cells_[owner_[fIndex]], faceI)
-    {
-        label faceIndex = cells_[owner_[fIndex]][faceI];
-
-        if (faceIndex == fIndex)
-        {
-            continue;
-        }
-
-        const face& faceToCheck = faces_[faceIndex];
-        label cellIndex = cellsForRemoval[0];
-        label newIndex = -1;
-
-        // Check against faces.
-        if (triFace::compare(triFace(faceToCheck), triFace(checkFace[0])))
-        {
-            newIndex = newCellIndex[0];
-            newTetCell[0][nF[0]++] = faceIndex;
-        }
-        else
-        if (triFace::compare(triFace(faceToCheck), triFace(checkFace[1])))
-        {
-            newIndex = newCellIndex[1];
-            newTetCell[1][nF[1]++] = faceIndex;
-        }
-        else
-        if (triFace::compare(triFace(faceToCheck), triFace(checkFace[2])))
-        {
-            newIndex = newCellIndex[2];
-            newTetCell[2][nF[2]++] = faceIndex;
-        }
-        else
-        {
-            // Something's terribly wrong.
-            FatalErrorIn
-            (
-                "const changeMap dynamicTopoFvMesh::trisectFace\n"
-                "(\n"
-                "    const label fIndex,\n"
-                "    bool checkOnly,\n"
-                "    bool forceOp\n"
-                ")\n"
-            )
-                << "Failed to determine a face match."
-                << abort(FatalError);
-        }
-
-        // Check if a face-flip is necessary
-        if (owner_[faceIndex] == cellIndex)
-        {
-            if (neighbour_[faceIndex] == -1)
-            {
-                // Change the owner
-                owner_[faceIndex] = newIndex;
-            }
-            else
-            {
-                // Flip this face
-                faces_[faceIndex] = faceToCheck.reverseFace();
-                owner_[faceIndex] = neighbour_[faceIndex];
-                neighbour_[faceIndex] = newIndex;
-
-                setFlip(faceIndex);
-            }
-        }
-        else
-        {
-            // Flip is unnecessary. Just update neighbour
-            neighbour_[faceIndex] = newIndex;
-        }
-    }
-
-    if (cellsForRemoval[1] == -1)
-    {
-        // Boundary face. Determine its patch.
-        label facePatch = whichPatch(fIndex);
-
-        // Add three new boundary faces.
-
-        // Fourth face: Owner: newCellIndex[0], Neighbour: -1
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][2];
-        tmpTriFace[2] = faces_[fIndex][0];
-
-        newFaceIndex[3] =
-        (
-            insertFace
-            (
-                facePatch,
-                tmpTriFace,
-                newCellIndex[0],
-                -1
-            )
-        );
-
-        // Fifth face: Owner: newCellIndex[1], Neighbour: -1
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][0];
-        tmpTriFace[2] = faces_[fIndex][1];
-
-        newFaceIndex[4] =
-        (
-            insertFace
-            (
-                facePatch,
-                tmpTriFace,
-                newCellIndex[1],
-                -1
-            )
-        );
-
-        // Sixth face: Owner: newCellIndex[2], Neighbour: -1
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][1];
-        tmpTriFace[2] = faces_[fIndex][2];
-
-        newFaceIndex[5] =
-        (
-            insertFace
-            (
-                facePatch,
-                tmpTriFace,
-                newCellIndex[2],
-                -1
-            )
-        );
-
-        // Add the newly created faces to cells
-        newTetCell[0][nF[0]++] = newFaceIndex[3];
-        newTetCell[1][nF[1]++] = newFaceIndex[4];
-        newTetCell[2][nF[2]++] = newFaceIndex[5];
-
-        // Configure edgeFaces for three new boundary edges.
-        newTriEdgeFaces[0] = newFaceIndex[4];
-        newTriEdgeFaces[1] = newFaceIndex[0];
-        newTriEdgeFaces[2] = newFaceIndex[3];
-
-        newEdgeIndex[1] =
-        (
-            insertEdge
-            (
-                facePatch,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][0]
-                ),
-                newTriEdgeFaces
-            )
-        );
-
-        newTriEdgeFaces[0] = newFaceIndex[5];
-        newTriEdgeFaces[1] = newFaceIndex[1];
-        newTriEdgeFaces[2] = newFaceIndex[4];
-
-        newEdgeIndex[2] =
-        (
-            insertEdge
-            (
-                facePatch,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][1]
-                ),
-                newTriEdgeFaces
-            )
-        );
-
-        newTriEdgeFaces[0] = newFaceIndex[3];
-        newTriEdgeFaces[1] = newFaceIndex[2];
-        newTriEdgeFaces[2] = newFaceIndex[5];
-
-        newEdgeIndex[3] =
-        (
-            insertEdge
-            (
-                facePatch,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][2]
-                ),
-                newTriEdgeFaces
-            )
-        );
-
-        // Configure faceEdges with the three new edges.
-        newFaceEdges[0][nE[0]++] = newEdgeIndex[1];
-        newFaceEdges[1][nE[1]++] = newEdgeIndex[2];
-        newFaceEdges[2][nE[2]++] = newEdgeIndex[3];
-
-        newFaceEdges[3][nE[3]++] = newEdgeIndex[1];
-        newFaceEdges[3][nE[3]++] = newEdgeIndex[3];
-        newFaceEdges[4][nE[4]++] = newEdgeIndex[1];
-        newFaceEdges[4][nE[4]++] = newEdgeIndex[2];
-        newFaceEdges[5][nE[5]++] = newEdgeIndex[2];
-        newFaceEdges[5][nE[5]++] = newEdgeIndex[3];
-
-        // Define the six edges to check while building faceEdges:
-        FixedList<edge,6> check;
-
-        check[0][0] = apexPoint[0]; check[0][1] = faces_[fIndex][0];
-        check[1][0] = apexPoint[0]; check[1][1] = faces_[fIndex][1];
-        check[2][0] = apexPoint[0]; check[2][1] = faces_[fIndex][2];
-
-        check[3][0] = faces_[fIndex][2]; check[3][1] = faces_[fIndex][0];
-        check[4][0] = faces_[fIndex][0]; check[4][1] = faces_[fIndex][1];
-        check[5][0] = faces_[fIndex][1]; check[5][1] = faces_[fIndex][2];
-
-        // Build a list of cellEdges
-        DynamicList<label> cellEdges(6);
-
-        forAll(cells_[owner_[fIndex]], faceI)
-        {
-            const labelList& fEdges =
-            (
-                faceEdges_[cells_[owner_[fIndex]][faceI]]
-            );
-
-            forAll(fEdges, edgeI)
-            {
-                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
-                {
-                    cellEdges.append(fEdges[edgeI]);
-                }
-            }
-        }
-
-        // Loop through cellEdges, and perform appropriate actions.
-        forAll(cellEdges, edgeI)
-        {
-            const label ceIndex = cellEdges[edgeI];
-            const edge& edgeToCheck = edges_[ceIndex];
-
-            // Check against the specified edges.
-            if (edgeToCheck == check[0])
-            {
-                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[ceIndex]);
-                newFaceEdges[0][nE[0]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[1])
-            {
-                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[ceIndex]);
-                newFaceEdges[1][nE[1]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[2])
-            {
-                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[ceIndex]);
-                newFaceEdges[2][nE[2]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[3])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[3],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[3][nE[3]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[4])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[4],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[4][nE[4]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[5])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[5],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[5][nE[5]++] = ceIndex;
-            }
-        }
-
-        // Now that faceEdges has been configured, append them to the list.
-        for (label i = 0; i < 6; i++)
-        {
-            faceEdges_.append(newFaceEdges[i]);
-
-            // 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
-    {
-        // Add three new cells to the end of the cell list
-        for (label i = 3; i < 6; i++)
-        {
-            scalar parentScale = -1.0;
-
-            if (edgeRefinement_)
-            {
-                parentScale = lengthScale_[cellsForRemoval[1]];
-            }
-
-            newCellIndex[i] = insertCell(newTetCell[i], parentScale);
-
-            // Add to the map.
-            map.addCell(newCellIndex[i]);
-        }
-
-        // Find the apex point for this cell
-        apexPoint[1] =
-        (
-            meshOps::tetApexPoint
-            (
-                neighbour_[fIndex],
-                fIndex,
-                faces_,
-                cells_
-            )
-        );
-
-        // Add six new interior faces.
-
-        // Fourth face: Owner: newCellIndex[0], Neighbour: newCellIndex[3]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][2];
-        tmpTriFace[2] = faces_[fIndex][0];
-
-        newFaceIndex[3] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[0],
-                newCellIndex[3]
-            )
-        );
-
-        // Fifth face: Owner: newCellIndex[1], Neighbour: newCellIndex[4]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][0];
-        tmpTriFace[2] = faces_[fIndex][1];
-
-        newFaceIndex[4] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[1],
-                newCellIndex[4]
-            )
-        );
-
-        // Sixth face: Owner: newCellIndex[2], Neighbour: newCellIndex[5]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][1];
-        tmpTriFace[2] = faces_[fIndex][2];
-
-        newFaceIndex[5] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[2],
-                newCellIndex[5]
-            )
-        );
-
-        // Seventh face: Owner: newCellIndex[3], Neighbour: newCellIndex[4]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = apexPoint[1];
-        tmpTriFace[2] = faces_[fIndex][0];
-
-        newFaceIndex[6] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[3],
-                newCellIndex[4]
-            )
-        );
-
-        // Eighth face: Owner: newCellIndex[4], Neighbour: newCellIndex[5]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = apexPoint[1];
-        tmpTriFace[2] = faces_[fIndex][1];
-
-        newFaceIndex[7] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[4],
-                newCellIndex[5]
-            )
-        );
-
-        // Ninth face: Owner: newCellIndex[3], Neighbour: newCellIndex[5]
-        tmpTriFace[0] = newPointIndex;
-        tmpTriFace[1] = faces_[fIndex][2];
-        tmpTriFace[2] = apexPoint[1];
-
-        newFaceIndex[8] =
-        (
-            insertFace
-            (
-                -1,
-                tmpTriFace,
-                newCellIndex[3],
-                newCellIndex[5]
-            )
-        );
-
-        // Add the newly created faces to cells
-        newTetCell[3][nF[3]++] = newFaceIndex[6];
-        newTetCell[3][nF[3]++] = newFaceIndex[8];
-        newTetCell[4][nF[4]++] = newFaceIndex[6];
-        newTetCell[4][nF[4]++] = newFaceIndex[7];
-        newTetCell[5][nF[5]++] = newFaceIndex[7];
-        newTetCell[5][nF[5]++] = newFaceIndex[8];
-
-        newTetCell[0][nF[0]++] = newFaceIndex[3];
-        newTetCell[1][nF[1]++] = newFaceIndex[4];
-        newTetCell[2][nF[2]++] = newFaceIndex[5];
-
-        newTetCell[3][nF[3]++] = newFaceIndex[3];
-        newTetCell[4][nF[4]++] = newFaceIndex[4];
-        newTetCell[5][nF[5]++] = newFaceIndex[5];
-
-        // Define the three faces to check for orientation:
-        checkFace[0][0] = faces_[fIndex][2];
-        checkFace[0][1] = apexPoint[1];
-        checkFace[0][2] = faces_[fIndex][0];
-
-        checkFace[1][0] = faces_[fIndex][0];
-        checkFace[1][1] = apexPoint[1];
-        checkFace[1][2] = faces_[fIndex][1];
-
-        checkFace[2][0] = faces_[fIndex][1];
-        checkFace[2][1] = apexPoint[1];
-        checkFace[2][2] = faces_[fIndex][2];
-
-        // Check the orientation of faces on the second cell.
-        forAll(cells_[neighbour_[fIndex]], faceI)
-        {
-            label faceIndex = cells_[neighbour_[fIndex]][faceI];
-
-            if (faceIndex == fIndex)
-            {
-                continue;
-            }
-
-            const face& faceToCheck = faces_[faceIndex];
-            label cellIndex = cellsForRemoval[1];
-            label newIndex = -1;
-
-            // Check against faces.
-            if (triFace::compare(triFace(faceToCheck), triFace(checkFace[0])))
-            {
-                newIndex = newCellIndex[3];
-                newTetCell[3][nF[3]++] = faceIndex;
-            }
-            else
-            if (triFace::compare(triFace(faceToCheck), triFace(checkFace[1])))
-            {
-                newIndex = newCellIndex[4];
-                newTetCell[4][nF[4]++] = faceIndex;
-            }
-            else
-            if (triFace::compare(triFace(faceToCheck), triFace(checkFace[2])))
-            {
-                newIndex = newCellIndex[5];
-                newTetCell[5][nF[5]++] = faceIndex;
-            }
-            else
-            {
-                // Something's terribly wrong.
-                FatalErrorIn
-                (
-                    "const changeMap dynamicTopoFvMesh::trisectFace\n"
-                    "(\n"
-                    "    const label fIndex,\n"
-                    "    bool checkOnly,\n"
-                    "    bool forceOp\n"
-                    ")\n"
-                )
-                    << "Failed to determine a face match."
-                    << abort(FatalError);
-            }
-
-            // Check if a face-flip is necessary
-            if (owner_[faceIndex] == cellIndex)
-            {
-                if (neighbour_[faceIndex] == -1)
-                {
-                    // Change the owner
-                    owner_[faceIndex] = newIndex;
-                }
-                else
-                {
-                    // Flip this face
-                    faces_[faceIndex] = faceToCheck.reverseFace();
-                    owner_[faceIndex] = neighbour_[faceIndex];
-                    neighbour_[faceIndex] = newIndex;
-
-                    setFlip(faceIndex);
-                }
-            }
-            else
-            {
-                // Flip is unnecessary. Just update neighbour
-                neighbour_[faceIndex] = newIndex;
-            }
-        }
-
-        // Configure edgeFaces for four new interior edges.
-        newQuadEdgeFaces[0] = newFaceIndex[4];
-        newQuadEdgeFaces[1] = newFaceIndex[0];
-        newQuadEdgeFaces[2] = newFaceIndex[3];
-        newQuadEdgeFaces[3] = newFaceIndex[6];
-
-        newEdgeIndex[1] =
-        (
-            insertEdge
-            (
-                -1,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][0]
-                ),
-                newQuadEdgeFaces
-            )
-        );
-
-        newQuadEdgeFaces[0] = newFaceIndex[5];
-        newQuadEdgeFaces[1] = newFaceIndex[1];
-        newQuadEdgeFaces[2] = newFaceIndex[4];
-        newQuadEdgeFaces[3] = newFaceIndex[7];
-
-        newEdgeIndex[2] =
-        (
-            insertEdge
-            (
-                -1,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][1]
-                ),
-                newQuadEdgeFaces
-            )
-        );
-
-        newQuadEdgeFaces[0] = newFaceIndex[3];
-        newQuadEdgeFaces[1] = newFaceIndex[2];
-        newQuadEdgeFaces[2] = newFaceIndex[5];
-        newQuadEdgeFaces[3] = newFaceIndex[8];
-
-        newEdgeIndex[3] =
-        (
-            insertEdge
-            (
-                -1,
-                edge
-                (
-                   newPointIndex,
-                   faces_[fIndex][2]
-                ),
-                newQuadEdgeFaces
-            )
-        );
-
-        newTriEdgeFaces[0] = newFaceIndex[6];
-        newTriEdgeFaces[1] = newFaceIndex[7];
-        newTriEdgeFaces[2] = newFaceIndex[8];
-
-        newEdgeIndex[4] =
-        (
-            insertEdge
-            (
-                -1,
-                edge
-                (
-                   apexPoint[1],
-                   newPointIndex
-                ),
-                newTriEdgeFaces
-            )
-        );
-
-        // Configure faceEdges with the new internal edges
-        newFaceEdges[0][nE[0]++] = newEdgeIndex[1];
-        newFaceEdges[1][nE[1]++] = newEdgeIndex[2];
-        newFaceEdges[2][nE[2]++] = newEdgeIndex[3];
-
-        newFaceEdges[3][nE[3]++] = newEdgeIndex[1];
-        newFaceEdges[3][nE[3]++] = newEdgeIndex[3];
-        newFaceEdges[4][nE[4]++] = newEdgeIndex[1];
-        newFaceEdges[4][nE[4]++] = newEdgeIndex[2];
-        newFaceEdges[5][nE[5]++] = newEdgeIndex[2];
-        newFaceEdges[5][nE[5]++] = newEdgeIndex[3];
-
-        newFaceEdges[6][nE[6]++] = newEdgeIndex[1];
-        newFaceEdges[7][nE[7]++] = newEdgeIndex[2];
-        newFaceEdges[8][nE[8]++] = newEdgeIndex[3];
-
-        newFaceEdges[6][nE[6]++] = newEdgeIndex[4];
-        newFaceEdges[7][nE[7]++] = newEdgeIndex[4];
-        newFaceEdges[8][nE[8]++] = newEdgeIndex[4];
-
-        // Define the nine edges to check while building faceEdges:
-        FixedList<edge,9> check;
-
-        check[0][0] = apexPoint[0]; check[0][1] = faces_[fIndex][0];
-        check[1][0] = apexPoint[0]; check[1][1] = faces_[fIndex][1];
-        check[2][0] = apexPoint[0]; check[2][1] = faces_[fIndex][2];
-
-        check[3][0] = faces_[fIndex][2]; check[3][1] = faces_[fIndex][0];
-        check[4][0] = faces_[fIndex][0]; check[4][1] = faces_[fIndex][1];
-        check[5][0] = faces_[fIndex][1]; check[5][1] = faces_[fIndex][2];
-
-        check[6][0] = apexPoint[1]; check[6][1] = faces_[fIndex][0];
-        check[7][0] = apexPoint[1]; check[7][1] = faces_[fIndex][1];
-        check[8][0] = apexPoint[1]; check[8][1] = faces_[fIndex][2];
-
-        // Build a list of cellEdges
-        DynamicList<label> cellEdges(12);
-
-        forAll(cells_[owner_[fIndex]], faceI)
-        {
-            const labelList& fEdges =
-            (
-                faceEdges_[cells_[owner_[fIndex]][faceI]]
-            );
-
-            forAll(fEdges, edgeI)
-            {
-                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
-                {
-                    cellEdges.append(fEdges[edgeI]);
-                }
-            }
-        }
-
-        forAll(cells_[neighbour_[fIndex]], faceI)
-        {
-            const labelList& fEdges =
-            (
-                faceEdges_[cells_[neighbour_[fIndex]][faceI]]
-            );
-
-            forAll(fEdges, edgeI)
-            {
-                if (findIndex(cellEdges, fEdges[edgeI]) == -1)
-                {
-                    cellEdges.append(fEdges[edgeI]);
-                }
-            }
-        }
-
-        // Loop through cellEdges, and perform appropriate actions.
-        forAll(cellEdges, edgeI)
-        {
-            const label ceIndex = cellEdges[edgeI];
-            const edge& edgeToCheck = edges_[ceIndex];
-
-            // Check against the specified edges.
-            if (edgeToCheck == check[0])
-            {
-                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[ceIndex]);
-                newFaceEdges[0][nE[0]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[1])
-            {
-                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[ceIndex]);
-                newFaceEdges[1][nE[1]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[2])
-            {
-                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[ceIndex]);
-                newFaceEdges[2][nE[2]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[3])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[3],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[3][nE[3]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[4])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[4],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[4][nE[4]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[5])
-            {
-                meshOps::replaceLabel
-                (
-                    fIndex,
-                    newFaceIndex[5],
-                    edgeFaces_[ceIndex]
-                );
-
-                newFaceEdges[5][nE[5]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[6])
-            {
-                meshOps::sizeUpList(newFaceIndex[6], edgeFaces_[ceIndex]);
-                newFaceEdges[6][nE[6]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[7])
-            {
-                meshOps::sizeUpList(newFaceIndex[7], edgeFaces_[ceIndex]);
-                newFaceEdges[7][nE[7]++] = ceIndex;
-            }
-
-            if (edgeToCheck == check[8])
-            {
-                meshOps::sizeUpList(newFaceIndex[8], edgeFaces_[ceIndex]);
-                newFaceEdges[8][nE[8]++] = ceIndex;
-            }
-        }
-
-        // Now that faceEdges has been configured, append them to the list.
-        for (label i = 0; i < 9; i++)
-        {
-            faceEdges_.append(newFaceEdges[i]);
-
-            // Add faces to the map.
-            map.addFace(newFaceIndex[i]);
-        }
-    }
-
-    // Added edges are those connected to the new point
-    const labelList& pointEdges = pointEdges_[newPointIndex];
-
-    forAll(pointEdges, edgeI)
-    {
-        map.addEdge(pointEdges[edgeI]);
-    }
-
-    // Now generate mapping info and remove entities.
-    forAll(cellsForRemoval, cellI)
-    {
-        label cIndex = cellsForRemoval[cellI];
-
-        if (cIndex == -1)
-        {
-            continue;
-        }
-
-        // Fill-in mapping information
-        labelList mC(1, cellsForRemoval[cellI]);
-
-        if (cellI == 0)
-        {
-            for (label i = 0; i < 3; i++)
-            {
-                // Update the cell list with newly configured cells.
-                cells_[newCellIndex[i]] = newTetCell[i];
-
-                setCellMapping(newCellIndex[i], mC);
-            }
-        }
-        else
-        {
-            for (label i = 3; i < 6; i++)
-            {
-                // Update the cell list with newly configured cells.
-                cells_[newCellIndex[i]] = newTetCell[i];
-
-                setCellMapping(newCellIndex[i], mC);
-            }
-        }
-
-        removeCell(cIndex);
-    }
-
-    // Set default mapping for interior faces.
-    for (label i = 0; i < 3; i++)
-    {
-        setFaceMapping(newFaceIndex[i]);
-    }
-
-    if (cellsForRemoval[1] == -1)
-    {
-        // Set mapping for boundary faces.
-        for (label i = 3; i < 6; i++)
-        {
-            setFaceMapping(newFaceIndex[i], labelList(1, fIndex));
-        }
-    }
-    else
-    {
-        // Set default mapping for interior faces.
-        for (label i = 3; i < 9; i++)
-        {
-            setFaceMapping(newFaceIndex[i]);
-        }
-    }
-
-    // Now finally remove the face...
-    removeFace(fIndex);
-
-    if (debug > 2)
-    {
-        Pout<< "New Point:: " << newPointIndex << endl;
-
-        const labelList& pEdges = pointEdges_[newPointIndex];
-
-        Pout<< "pointEdges:: " << pEdges << endl;
-
-        Pout<< "Added edges: " << endl;
-
-        forAll(pEdges, edgeI)
-        {
-            Pout<< pEdges[edgeI]
-                << ":: " << edges_[pEdges[edgeI]] << nl
-                << " edgeFaces:: " << edgeFaces_[pEdges[edgeI]] << nl
-                << endl;
-        }
-
-        Pout<< "Added faces: " << endl;
-
-        forAll(newFaceIndex, faceI)
-        {
-            if (newFaceIndex[faceI] == -1)
-            {
-                continue;
-            }
-
-            Pout<< newFaceIndex[faceI] << ":: "
-                << faces_[newFaceIndex[faceI]]
-                << endl;
-        }
-
-        Pout<< "Added cells: " << endl;
-
-        forAll(newCellIndex, cellI)
-        {
-            if (newCellIndex[cellI] == -1)
-            {
-                continue;
-            }
-
-            Pout<< newCellIndex[cellI] << ":: "
-                << cells_[newCellIndex[cellI]]
-                << endl;
-        }
-
-        // Write out VTK files after change
-        if (debug > 3)
-        {
-            labelList vtkCells;
-
-            if (cellsForRemoval[1] == -1)
-            {
-                vtkCells.setSize(3);
-
-                // Fill in cell indices
-                vtkCells[0] = newCellIndex[0];
-                vtkCells[1] = newCellIndex[1];
-                vtkCells[2] = newCellIndex[2];
-            }
-            else
-            {
-                vtkCells.setSize(6);
-
-                // Fill in cell indices
-                forAll(newCellIndex, indexI)
-                {
-                    vtkCells[indexI] = newCellIndex[indexI];
-                }
-            }
-
-            writeVTK
-            (
-                Foam::name(fIndex)
-              + "Trisect_1",
-                vtkCells
-            );
-        }
-    }
-
-    // Set the flag
-    topoChangeFlag_ = true;
-
-    // Increment the counter
-    statistics_[3]++;
-
-    // Increment the number of modifications
-    statistics_[0]++;
+    status(TOTAL_MODIFICATIONS)++;
 
     // Specify that the operation was successful
     map.type() = 1;
@@ -5840,11 +4202,10 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
         {
             const face& checkFace = faces_[checkCell[faceI]];
 
-            if
-            (
-                (findIndex(checkFace, edgeToCheck[0]) == -1) &&
-                (findIndex(checkFace, edgeToCheck[1]) == -1)
-            )
+            bool check0 = (findIndex(checkFace, edgeToCheck[0]) == -1);
+            bool check1 = (findIndex(checkFace, edgeToCheck[1]) == -1);
+
+            if ((check0 && !check1) || (!check0 && check1))
             {
                 // Check orientation
                 if (owner_[checkCell[faceI]] == cellIndex)
@@ -5940,83 +4301,6 @@ scalar dynamicTopoFvMesh::computeBisectionQuality
 }
 
 
-// Utility method to compute the quality of cells
-// around a face after trisection.
-scalar dynamicTopoFvMesh::computeTrisectionQuality
-(
-    const label fIndex
-) const
-{
-    scalar minQuality = GREAT;
-    scalar cQuality = 0.0;
-
-    point midPoint;
-
-    // Fetch the midPoint
-    midPoint = faces_[fIndex].centre(points_);
-
-    FixedList<label,2> apexPoint(-1);
-
-    // Find the apex point
-    apexPoint[0] =
-    (
-        meshOps::tetApexPoint
-        (
-            owner_[fIndex],
-            fIndex,
-            faces_,
-            cells_
-        )
-    );
-
-    const face& faceToCheck = faces_[fIndex];
-
-    forAll(faceToCheck, pointI)
-    {
-        // Pick vertices off the list
-        const point& b = points_[faceToCheck[pointI]];
-        const point& c = points_[apexPoint[0]];
-        const point& d = points_[faceToCheck[faceToCheck.fcIndex(pointI)]];
-
-        // Compute the quality of the upper half.
-        cQuality = tetMetric_(midPoint, b, c, d);
-
-        // Check if the quality is worse
-        minQuality = Foam::min(cQuality, minQuality);
-    }
-
-    if (whichPatch(fIndex) == -1)
-    {
-        apexPoint[1] =
-        (
-            meshOps::tetApexPoint
-            (
-                neighbour_[fIndex],
-                fIndex,
-                faces_,
-                cells_
-            )
-        );
-
-        forAll(faceToCheck, pointI)
-        {
-            // Pick vertices off the list
-            const point& b = points_[faceToCheck[pointI]];
-            const point& c = points_[apexPoint[1]];
-            const point& d = points_[faceToCheck[faceToCheck.rcIndex(pointI)]];
-
-            // Compute the quality of the upper half.
-            cQuality = tetMetric_(midPoint, b, c, d);
-
-            // Check if the quality is worse
-            minQuality = Foam::min(cQuality, minQuality);
-        }
-    }
-
-    return minQuality;
-}
-
-
 // Slice the mesh at a particular location
 void dynamicTopoFvMesh::sliceMesh
 (
@@ -6035,7 +4319,7 @@ void dynamicTopoFvMesh::sliceMesh
     vector gCentre = vector::zero;
     FixedList<vector, 2> fC(vector::zero);
 
-    if (twoDMesh_)
+    if (is2D())
     {
         patchIndex = whichPatch(pointPair.first());
 
@@ -6095,7 +4379,7 @@ void dynamicTopoFvMesh::sliceMesh
     Map<vector> checkPoints, surfFaces;
     Map<edge> checkEdges;
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // Assign plane point / normal
         p = gCentre;
@@ -6371,7 +4655,7 @@ void dynamicTopoFvMesh::sliceMesh
             continue;
         }
 
-        if (twoDMesh_ && faces_[faceI].size() == 3)
+        if (is2D() && faces_[faceI].size() == 3)
         {
             continue;
         }
@@ -6435,7 +4719,7 @@ void dynamicTopoFvMesh::sliceMesh
         // 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_)
+        if (is2D())
         {
             const labelList& fEdges = faceEdges_[fIter.key()];
 
@@ -6657,7 +4941,7 @@ const changeMap dynamicTopoFvMesh::addCellLayer
         addedCells.insert(cIndex, labelPair(newCellIndex, 0));
     }
 
-    FixedList<label, 2> mP(-1);
+    labelList mP(2, -1);
 
     forAll(patchFaces, indexI)
     {
@@ -6942,13 +5226,11 @@ const changeMap dynamicTopoFvMesh::addCellLayer
                     whichPatch(vFaceIndex),
                     newVFace,
                     newOwner,
-                    newNeighbour
+                    newNeighbour,
+                    newVFaceEdges
                 )
             );
 
-            // Add a faceEdges entry
-            faceEdges_.append(newVFaceEdges);
-
             // Update maps
             map.addFace(newVFaceIndex, labelList(1, vFaceIndex));
             addedVFaces.insert(beIndex, newVFaceIndex);
@@ -6994,13 +5276,11 @@ const changeMap dynamicTopoFvMesh::addCellLayer
                 -1,
                 newHFace,
                 cIndex,
-                addedCells[cIndex].first()
+                addedCells[cIndex].first(),
+                newHFaceEdges
             )
         );
 
-        // Add a faceEdges entry
-        faceEdges_.append(newHFaceEdges);
-
         // Update maps
         map.addFace(newHFaceIndex, labelList(1, faceI));
         addedHFaces.insert(faceI, newHFaceIndex);
@@ -7052,7 +5332,7 @@ const changeMap dynamicTopoFvMesh::addCellLayer
         }
 
         // Size down pointEdges
-        if (!twoDMesh_)
+        if (is3D())
         {
             meshOps::sizeDownList
             (
@@ -7189,7 +5469,7 @@ void dynamicTopoFvMesh::splitInternalFaces
 
         pIter() = insertPoint(newPoint, oldPoint, labelList(1, pIter.key()));
 
-        if (!twoDMesh_)
+        if (is3D())
         {
             const labelList& pEdges = pointEdges_[pIter.key()];
 
@@ -7256,7 +5536,7 @@ void dynamicTopoFvMesh::splitInternalFaces
         label i = 0;
         labelList mPoints(mirrorPointLabels.size());
 
-        if (!twoDMesh_)
+        if (is3D())
         {
             forAllIter(Map<label>, mirrorPointLabels, pIter)
             {
@@ -7364,6 +5644,10 @@ void dynamicTopoFvMesh::splitInternalFaces
         // Insert the new boundary faces.
         forAll(newFace, indexI)
         {
+            // Make an identical faceEdges entry.
+            // This will be renumbered once new edges are added.
+            labelList newFaceEdges(faceEdges_[internalFaces[faceI]]);
+
             newFaceIndex[indexI] =
             (
                 insertFace
@@ -7371,16 +5655,11 @@ void dynamicTopoFvMesh::splitInternalFaces
                     patchIndex,
                     newFace[indexI],
                     newOwner[indexI],
-                    -1
+                    -1,
+                    newFaceEdges
                 )
             );
 
-            // Make an identical faceEdges entry.
-            // This will be renumbered once new edges are added.
-            labelList newFaceEdges(faceEdges_[internalFaces[faceI]]);
-
-            faceEdges_.append(newFaceEdges);
-
             // Replace face labels on cells
             meshOps::replaceLabel
             (
@@ -7531,7 +5810,7 @@ void dynamicTopoFvMesh::splitInternalFaces
         }
     }
 
-    if (twoDMesh_)
+    if (is2D())
     {
         // Renumber edges and faces
         forAllIter(Map<label>, mirrorEdgeLabels[0], eIter)
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
index 454f0d5bb..72fdad182 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
@@ -24,12 +24,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "Stack.H"
-#include "objectRegistry.H"
 #include "triFace.H"
 #include "objectMap.H"
 #include "changeMap.H"
-#include "multiThreader.H"
 #include "coupledInfo.H"
+#include "multiThreader.H"
 #include "dynamicTopoFvMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -71,7 +70,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
     if
     (
-        (statistics_[0] > maxModifications_)
+        (status(TOTAL_MODIFICATIONS) > maxModifications_)
      && (maxModifications_ > -1)
     )
     {
@@ -231,15 +230,23 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             forAll(procIndices_, pI)
             {
                 // Fetch reference to subMeshes
-                const coupledInfo& sendMesh = sendMeshes_[pI];
-                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupledMesh& sendMesh = sendMeshes_[pI];
+                const coupledMesh& 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
+                (
+                    priority
+                    (
+                        procIndices_[pI],
+                        lessOp<label>(),
+                        Pstream::myProcNo()
+                    )
+                )
                 {
                     if (scMap.reverseEntityMap(faceEnum).found(fIndex))
                     {
@@ -263,7 +270,15 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 {
                     // Check if a lower-ranked processor is
                     // handling this face
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                         if (debug > 3)
                         {
@@ -308,7 +323,15 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
                     // Check if a lower-ranked processor is
                     // handling this face
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                          if (debug > 3)
                          {
@@ -935,12 +958,12 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             }
             else
             {
+                const coupleMap& cMap = recvMeshes_[pI].map();
                 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)];
@@ -985,6 +1008,43 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                             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;
+                        }
+                    }
                 }
             }
 
@@ -1382,7 +1442,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             << "faceEdges: " << fE << " is to be collapsed. "
             << nl;
 
-        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " On SubMesh: " << isSubMesh_ << nl;
         Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichPatch(fIndex);
@@ -1579,7 +1639,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 (
                     Foam::name(fIndex)
                   + "_Collapse_0",
-                    vtkCells.toc()
+                    vtkCells.toc(),
+                    3, false, true
                 );
             }
         }
@@ -2588,6 +2649,125 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     // Remove orphaned faces
     if (owner_[faceToKeep[0]] == -1)
     {
+        const face& keepFace = faces_[faceToKeep[0]];
+        const labelList& rmFE = faceEdges_[faceToKeep[0]];
+
+        labelList keepPoints(keepFace.size(), 0);
+
+        forAll(rmFE, edgeI)
+        {
+            label eIndex = rmFE[edgeI];
+            labelList& eFaces = edgeFaces_[eIndex];
+            const edge& checkEdge = edges_[eIndex];
+
+            if
+            (
+                (eFaces.size() == 1) &&
+                (eFaces[0] == faceToKeep[0])
+            )
+            {
+                // This edge has to be removed entirely.
+                removeEdge(eIndex);
+
+                // Update map
+                map.removeEdge(eIndex);
+            }
+            else
+            {
+                // Mark points
+                keepPoints[keepFace.which(checkEdge[0])] = 1;
+                keepPoints[keepFace.which(checkEdge[1])] = 1;
+
+                // Size-down edgeFaces
+                meshOps::sizeDownList
+                (
+                    faceToKeep[0],
+                    eFaces
+                );
+            }
+        }
+
+        // Check if processor patches are being
+        // converted into physical ones
+        label neiProc = -1;
+        label kfPatch = whichPatch(faceToKeep[0]);
+        label rfPatch = whichPatch(faceToThrow[0]);
+
+        if
+        (
+            (getNeighbourProcessor(kfPatch) == -1) &&
+            ((neiProc = getNeighbourProcessor(rfPatch)) > -1)
+        )
+        {
+            if (isSubMesh_)
+            {
+                // If this is a subMesh, and faceToKeep is on
+                // a physical boundary, make a 'special' entry
+                // for coupled mapping purposes.
+                map.addFace
+                (
+                    faceToThrow[0],
+                    labelList(1, (-2 - kfPatch))
+                );
+            }
+            else
+            {
+                // This is a wierd overhanging cell on the master
+                // processor which is being removed entirely.
+                // Since the processor patch face is being converted
+                // to a physical one, the slave processor needs to
+                // be notified of the change.
+                forAll(procIndices_, pI)
+                {
+                    if (procIndices_[pI] == neiProc)
+                    {
+                        // Find slave index from the face map
+                        const coupleMap& cMap = recvMeshes_[pI].map();
+
+                        label replaceFace =
+                        (
+                            cMap.findSlave
+                            (
+                                coupleMap::FACE,
+                                faceToThrow[0]
+                            )
+                        );
+
+                        if (replaceFace == -1)
+                        {
+                            // Something is wrong here.
+                            Pout<< " Could not find slave face for: " << nl
+                                << "  Master face: " << faceToThrow[0]
+                                << "  :: " << faces_[faceToThrow[0]] << nl
+                                << "  on proc: " << procIndices_[pI] << nl
+                                << "  on converting to patch: " << kfPatch
+                                << abort(FatalError);
+                        }
+
+                        cMap.pushOperation
+                        (
+                            replaceFace,
+                            coupleMap::CONVERT_PHYSICAL,
+                            kfPatch
+                        );
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Remove unused points
+        forAll(keepPoints, pointI)
+        {
+            if (keepPoints[pointI] == 0)
+            {
+                removePoint(keepFace[pointI]);
+                map.removePoint(keepFace[pointI]);
+            }
+        }
+
+        // Remove the face
         removeFace(faceToKeep[0]);
 
         // Update map
@@ -2608,6 +2788,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
         // This face is being converted from interior to boundary. Remove
         // from the interior list and add as a boundary face to the end.
+        // Edges don't have to change, since they're all on the boundary anyway.
         label newFaceIndex =
         (
             insertFace
@@ -2615,7 +2796,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 whichPatch(faceToThrow[0]),
                 newFace,
                 newOwn,
-                -1
+                -1,
+                newFaceEdges
             )
         );
 
@@ -2625,11 +2807,6 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         // Update map
         map.addFace(newFaceIndex, labelList(1, faceToThrow[0]));
 
-        // 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
         (
             faceToKeep[0],
@@ -2690,13 +2867,132 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     if (c1 == -1)
     {
         // Increment the surface-collapse counter
-        statistics_[6]++;
+        status(SURFACE_COLLAPSES)++;
     }
     else
     {
         // Remove orphaned faces
         if (owner_[faceToKeep[1]] == -1)
         {
+            const face& keepFace = faces_[faceToKeep[1]];
+            const labelList& rmFE = faceEdges_[faceToKeep[1]];
+
+            labelList keepPoints(keepFace.size(), 0);
+
+            forAll(rmFE, edgeI)
+            {
+                label eIndex = rmFE[edgeI];
+                labelList& eFaces = edgeFaces_[eIndex];
+                const edge& checkEdge = edges_[eIndex];
+
+                if
+                (
+                    (eFaces.size() == 1) &&
+                    (eFaces[0] == faceToKeep[1])
+                )
+                {
+                    // This edge has to be removed entirely.
+                    removeEdge(eIndex);
+
+                    // Update map
+                    map.removeEdge(eIndex);
+                }
+                else
+                {
+                    // Mark points
+                    keepPoints[keepFace.which(checkEdge[0])] = 1;
+                    keepPoints[keepFace.which(checkEdge[1])] = 1;
+
+                    // Size-down edgeFaces
+                    meshOps::sizeDownList
+                    (
+                        faceToKeep[1],
+                        eFaces
+                    );
+                }
+            }
+
+            // Check if processor patches are being
+            // converted into physical ones
+            label neiProc = -1;
+            label kfPatch = whichPatch(faceToKeep[1]);
+            label rfPatch = whichPatch(faceToThrow[1]);
+
+            if
+            (
+                (getNeighbourProcessor(kfPatch) == -1) &&
+                ((neiProc = getNeighbourProcessor(rfPatch)) > -1)
+            )
+            {
+                if (isSubMesh_)
+                {
+                    // If this is a subMesh, and faceToKeep is on
+                    // a physical boundary, make a 'special' entry
+                    // for coupled mapping purposes.
+                    map.addFace
+                    (
+                        faceToThrow[1],
+                        labelList(1, (-2 - kfPatch))
+                    );
+                }
+                else
+                {
+                    // This is a wierd overhanging cell on the master
+                    // processor which is being removed entirely.
+                    // Since the processor patch face is being converted
+                    // to a physical one, the slave processor needs to
+                    // be notified of the change.
+                    forAll(procIndices_, pI)
+                    {
+                        if (procIndices_[pI] == neiProc)
+                        {
+                            // Find slave index from the face map
+                            const coupleMap& cMap = recvMeshes_[pI].map();
+
+                            label replaceFace =
+                            (
+                                cMap.findSlave
+                                (
+                                    coupleMap::FACE,
+                                    faceToThrow[1]
+                                )
+                            );
+
+                            if (replaceFace == -1)
+                            {
+                                // Something is wrong here.
+                                Pout<< " Could not find slave face for: " << nl
+                                    << "  Master face: " << faceToThrow[1]
+                                    << "  :: " << faces_[faceToThrow[1]] << nl
+                                    << "  on proc: " << procIndices_[pI] << nl
+                                    << "  on converting to patch: " << kfPatch
+                                    << abort(FatalError);
+                            }
+
+                            cMap.pushOperation
+                            (
+                                replaceFace,
+                                coupleMap::CONVERT_PHYSICAL,
+                                kfPatch
+                            );
+
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Remove unused points
+            forAll(keepPoints, pointI)
+            {
+                if (keepPoints[pointI] == 0)
+                {
+                    removePoint(keepFace[pointI]);
+                    map.removePoint(keepFace[pointI]);
+                }
+            }
+
+            // Remove the face
             removeFace(faceToKeep[1]);
 
             // Update map
@@ -2717,6 +3013,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
 
             // This face is being converted from interior to boundary. Remove
             // from the interior list and add as a boundary face to the end.
+            // Edges don't have to change, since they're on the boundary anyway.
             label newFaceIndex =
             (
                 insertFace
@@ -2724,7 +3021,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     whichPatch(faceToThrow[1]),
                     newFace,
                     newOwn,
-                    -1
+                    -1,
+                    newFaceEdges
                 )
             );
 
@@ -2734,11 +3032,6 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
             // Update map
             map.addFace(newFaceIndex, labelList(1, faceToThrow[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
             (
                 faceToKeep[1],
@@ -2843,7 +3136,8 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
         (
             Foam::name(fIndex)
           + "_Collapse_1",
-            vtkCells.toc()
+            vtkCells.toc(),
+            3, false, true
         );
     }
 
@@ -2921,6 +3215,12 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 }
             }
 
+            if (faceCandidates.empty())
+            {
+                // Add the face itself
+                faceCandidates.setSize(1, mfIndex);
+            }
+
             // Set the mapping for this face
             setFaceMapping(mfIndex, faceCandidates);
         }
@@ -2959,7 +3259,7 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 // Check coupleMaps for point coupling
                 const label pointEnum = coupleMap::POINT;
 
-                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupledMesh& recvMesh = recvMeshes_[pI];
                 const coupleMap& cMap = recvMesh.map();
 
                 // Obtain non-const references
@@ -3096,7 +3396,16 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     rPointMap[replacement[0]] = srP1;
                 }
 
-                pointMap.erase(rPointMap[original[0]]);
+                if (rPointMap[original[0]] == scP0)
+                {
+                    pointMap.erase(scP0);
+                }
+                else
+                if (rPointMap[original[0]] == scP1)
+                {
+                    pointMap.erase(scP1);
+                }
+
                 rPointMap.erase(original[0]);
             }
             else
@@ -3113,7 +3422,16 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     pointMap[replacement[0]] = srP1;
                 }
 
-                rPointMap.erase(pointMap[original[0]]);
+                if (pointMap[original[0]] == scP0)
+                {
+                    rPointMap.erase(scP0);
+                }
+                else
+                if (pointMap[original[0]] == scP1)
+                {
+                    rPointMap.erase(scP1);
+                }
+
                 pointMap.erase(original[0]);
             }
 
@@ -3131,7 +3449,16 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     rPointMap[replacement[1]] = srP1;
                 }
 
-                pointMap.erase(rPointMap[original[1]]);
+                if (rPointMap[original[1]] == scP0)
+                {
+                    pointMap.erase(scP0);
+                }
+                else
+                if (rPointMap[original[1]] == scP1)
+                {
+                    pointMap.erase(scP1);
+                }
+
                 rPointMap.erase(original[1]);
             }
             else
@@ -3148,7 +3475,16 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                     pointMap[replacement[1]] = srP1;
                 }
 
-                rPointMap.erase(pointMap[original[1]]);
+                if (pointMap[original[1]] == scP0)
+                {
+                    rPointMap.erase(scP0);
+                }
+                else
+                if (pointMap[original[1]] == scP1)
+                {
+                    rPointMap.erase(scP1);
+                }
+
                 pointMap.erase(original[1]);
             }
 
@@ -3372,20 +3708,103 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                 label sfPatch = sMesh.whichPatch(sfIndex);
 
                 // Skip dissimilar patches
-                if (ofPatch != sfPatch)
+                if (ofPatch != sfPatch && localCouple)
                 {
                     continue;
                 }
 
                 const face& sFace = sMesh.faces_[sfIndex];
 
-                forAll(cFace, pointI)
+                if (sFace.empty())
                 {
-                    cFace[pointI] =
+                    // Slave face was removed. Update map.
+                    Map<label>::iterator sit = rFaceMap.find(sfIndex);
+
+                    label mfIndex = -1;
+
+                    if (sit != rFaceMap.end())
+                    {
+                        mfIndex = sit();
+                        faceMap.erase(sit());
+                        rFaceMap.erase(sit);
+                    }
+
+                    // Check if this is a special entry
+                    label mo =
                     (
-                        rPointMap.found(sFace[pointI]) ?
-                        rPointMap[sFace[pointI]] : -1
+                        sadF[faceI].masterObjects().size() ?
+                        sadF[faceI].masterObjects()[0] : 0
                     );
+
+                    // Check if a patch conversion is necessary
+                    label newPatch = -1;
+
+                    // Back out the physical patch ID
+                    if (mo < 0 && mfIndex > -1)
+                    {
+                        newPatch = Foam::mag(mo + 2);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    // 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,
+                            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));
+
+                    continue;
+                }
+                else
+                {
+                    forAll(cFace, pointI)
+                    {
+                        cFace[pointI] =
+                        (
+                            rPointMap.found(sFace[pointI]) ?
+                            rPointMap[sFace[pointI]] : -1
+                        );
+                    }
                 }
 
                 bool matchedFace = false;
@@ -3479,43 +3898,6 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
                         << 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;
-                }
-            }
         }
     }
 
@@ -3523,10 +3905,10 @@ const changeMap dynamicTopoFvMesh::collapseQuadFace
     topoChangeFlag_ = true;
 
     // Increment the counter
-    statistics_[4]++;
+    status(TOTAL_COLLAPSES)++;
 
     // Increment the number of modifications
-    statistics_[0]++;
+    status(TOTAL_MODIFICATIONS)++;
 
     // Return a succesful collapse
     map.type() = collapseCase;
@@ -3572,7 +3954,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     //      Update faceEdges and edgeFaces information
 
     // For 2D meshes, perform face-collapse
-    if (twoDMesh_)
+    if (is2D())
     {
         return collapseQuadFace(eIndex, overRideCase, checkOnly);
     }
@@ -3587,7 +3969,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
     if
     (
-        (statistics_[0] > maxModifications_)
+        (status(TOTAL_MODIFICATIONS) > maxModifications_)
      && (maxModifications_ > -1)
     )
     {
@@ -3739,15 +4121,23 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             forAll(procIndices_, pI)
             {
                 // Fetch reference to subMeshes
-                const coupledInfo& sendMesh = sendMeshes_[pI];
-                const coupledInfo& recvMesh = recvMeshes_[pI];
+                const coupledMesh& sendMesh = sendMeshes_[pI];
+                const coupledMesh& 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
+                (
+                    priority
+                    (
+                        procIndices_[pI],
+                        lessOp<label>(),
+                        Pstream::myProcNo()
+                    )
+                )
                 {
                     if (scMap.reverseEntityMap(edgeEnum).found(eIndex))
                     {
@@ -3771,7 +4161,15 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 {
                     // Check if a lower-ranked processor is
                     // handling this edge
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                         if (debug > 3)
                         {
@@ -3810,7 +4208,15 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
                     // Check if a lower-ranked processor is
                     // handling this edge
-                    if (procIndices_[pI] < Pstream::myProcNo())
+                    if
+                    (
+                        priority
+                        (
+                            procIndices_[pI],
+                            lessOp<label>(),
+                            Pstream::myProcNo()
+                        )
+                    )
                     {
                          if (debug > 3)
                          {
@@ -4750,7 +5156,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             << "Edge: " << eIndex << ": " << edges_[eIndex]
             << " is to be collapsed. " << nl;
 
-        Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+        Pout<< " On SubMesh: " << isSubMesh_ << nl;
         Pout<< " coupledModification: " << coupledModification_ << nl;
 
         label epIndex = whichEdgePatch(eIndex);
@@ -4874,7 +5280,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
     if (whichEdgePatch(eIndex) > -1)
     {
         // Update number of surface collapses, if necessary.
-        statistics_[6]++;
+        status(SURFACE_COLLAPSES)++;
     }
 
     // Maintain a list of modified faces for mapping
@@ -5068,7 +5474,8 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                             whichPatch(faceToRemove),
                             newFace,
                             newOwner,
-                            newNeighbour
+                            newNeighbour,
+                            newFE
                         )
                     );
 
@@ -5152,7 +5559,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                     }
 
                     // Add the new faceEdges
-                    faceEdges_.append(newFE);
+                    faceEdges_[newFaceIndex] = newFE;
 
                     // Replace edgeFaces with the new face index
                     const labelList& newFEdges = faceEdges_[newFaceIndex];
@@ -5292,7 +5699,8 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         whichPatch(faceToRemove),
                         newFace,
                         newOwner,
-                        newNeighbour
+                        newNeighbour,
+                        newFE
                     )
                 );
 
@@ -5376,7 +5784,7 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 }
 
                 // Add the new faceEdges
-                faceEdges_.append(newFE);
+                faceEdges_[newFaceIndex] = newFE;
 
                 // Replace edgeFaces with the new face index
                 const labelList& newFEdges = faceEdges_[newFaceIndex];
@@ -5677,9 +6085,15 @@ const changeMap dynamicTopoFvMesh::collapseEdge
         }
     }
 
+    // Create a list of candidates for mapping
+    // using the list of checked cells
+    labelList mC(cellsChecked.size());
+
     // For cell-mapping, exclude all hull-cells
     forAll(cellsChecked, indexI)
     {
+        mC[indexI] = cellsChecked[indexI];
+
         if (cells_[cellsChecked[indexI]].empty())
         {
             cellsChecked[indexI] = -1;
@@ -5715,9 +6129,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             continue;
         }
 
-        // Fill-in candidate mapping information
-        labelList mC(1, cellsChecked[cellI]);
-
         // Set the mapping for this cell
         setCellMapping(cellsChecked[cellI], mC);
     }
@@ -5773,6 +6184,12 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                 }
             }
 
+            if (faceCandidates.empty())
+            {
+                // Add the face itself
+                faceCandidates.setSize(1, mfIndex);
+            }
+
             // Set the mapping for this face
             setFaceMapping(mfIndex, faceCandidates);
         }
@@ -5844,6 +6261,10 @@ const changeMap dynamicTopoFvMesh::collapseEdge
             }
         }
 
+        // Prepare a checklist
+        boolList matchedFaces(checkFaces.size(), false);
+        boolList matchedEdges(checkEdges.size(), false);
+
         // Output check entities
         if (debug > 4)
         {
@@ -5945,8 +6366,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         << abort(FatalError);
                 }
 
-                bool matchedFace = false;
-
                 // Fetch edges connected to first slave point
                 const labelList& spEdges = pointEdges_[cF[0]];
 
@@ -5961,9 +6380,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
                     const labelList& seFaces = edgeFaces_[seIndex];
 
-                    forAll(seFaces, faceI)
+                    forAll(seFaces, faceJ)
                     {
-                        label sfIndex = seFaces[faceI];
+                        label sfIndex = seFaces[faceJ];
 
                         if (whichPatch(sfIndex) == -1)
                         {
@@ -6010,25 +6429,25 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 faceMap.insert(mfIndex, sfIndex);
                             }
 
-                            matchedFace = true;
+                            matchedFaces[faceI] = true;
 
                             break;
                         }
                     }
 
-                    if (matchedFace)
+                    if (matchedFaces[faceI])
                     {
                         break;
                     }
                 }
 
-                if (!matchedFace)
+                if (!matchedFaces[faceI])
                 {
                     writeVTK
                     (
                         "failedFacePoints_"
                       + Foam::name(mfIndex),
-                        cF, 0, false, true
+                        labelList(cF), 0, false, true
                     );
 
                     Pout<< " Failed to match face: "
@@ -6073,8 +6492,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         << abort(FatalError);
                 }
 
-                bool matchedEdge = false;
-
                 // Fetch edges connected to first slave point
                 const labelList& spEdges = pointEdges_[cE[0]];
 
@@ -6115,19 +6532,19 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                             edgeMap.insert(meIndex, seIndex);
                         }
 
-                        matchedEdge = true;
+                        matchedEdges[edgeI] = true;
 
                         break;
                     }
                 }
 
-                if (!matchedEdge)
+                if (!matchedEdges[edgeI])
                 {
                     writeVTK
                     (
                         "failedEdgePoints_"
                       + Foam::name(meIndex),
-                        cE, 0, false, true
+                        labelList(cE), 0, false, true
                     );
 
                     Pout<< " Failed to match edge: "
@@ -6449,12 +6866,11 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 newPatch,
                                 newFace,
                                 newOwn,
-                                -1
+                                -1,
+                                newFaceEdges
                             )
                         );
 
-                        faceEdges_.append(newFaceEdges);
-
                         meshOps::replaceLabel
                         (
                             mfIndex,
@@ -6507,8 +6923,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         );
                     }
 
-                    bool matchedFace = false;
-
                     // Fetch edges connected to first slave point
                     const labelList& spEdges = sMesh.pointEdges_[cF[0]];
 
@@ -6523,9 +6937,9 @@ const changeMap dynamicTopoFvMesh::collapseEdge
 
                         const labelList& seFaces = sMesh.edgeFaces_[seIndex];
 
-                        forAll(seFaces, faceI)
+                        forAll(seFaces, faceJ)
                         {
-                            label sfIndex = seFaces[faceI];
+                            label sfIndex = seFaces[faceJ];
 
                             if (sMesh.whichPatch(sfIndex) == -1)
                             {
@@ -6573,32 +6987,32 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                     faceMap.insert(mfIndex, sfIndex);
                                 }
 
-                                matchedFace = true;
+                                matchedFaces[faceI] = true;
 
                                 break;
                             }
                         }
 
-                        if (matchedFace)
+                        if (matchedFaces[faceI])
                         {
                             break;
                         }
                     }
 
-                    if (!matchedFace)
+                    if ((debug > 4) && !matchedFaces[faceI])
                     {
                         sMesh.writeVTK
                         (
                             "failedFacePoints_"
                           + Foam::name(mfIndex),
-                            cF, 0, false, true
+                            labelList(cF), 0, false, true
                         );
 
                         Pout<< " Failed to match face: "
                             << mfIndex << " :: " << faces_[mfIndex]
                             << " using comparison face: " << cF
                             << " on proc: " << procIndices_[pI]
-                            << abort(FatalError);
+                            << endl;
                     }
                 }
             }
@@ -6755,8 +7169,6 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                         }
                     }
 
-                    bool matchedEdge = false;
-
                     // Fetch edges connected to first slave point
                     const labelList& spEdges = sMesh.pointEdges_[cE[0]];
 
@@ -6798,13 +7210,13 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 edgeMap.insert(meIndex, seIndex);
                             }
 
-                            matchedEdge = true;
+                            matchedEdges[edgeI] = true;
 
                             break;
                         }
                     }
 
-                    if (!matchedEdge)
+                    if (!matchedEdges[edgeI])
                     {
                         // Check if a coupling existed before
                         if (edgeMap.found(meIndex) && slaveMapPtr)
@@ -6830,39 +7242,66 @@ const changeMap dynamicTopoFvMesh::collapseEdge
                                 rEdgeMap.erase(edgeMap[meIndex]);
                                 edgeMap.erase(meIndex);
 
-                                matchedEdge = true;
+                                matchedEdges[edgeI] = true;
                             }
                         }
                     }
 
-                    if (!matchedEdge)
+                    if ((debug > 4) && !matchedEdges[edgeI])
                     {
                         sMesh.writeVTK
                         (
                             "failedEdgePoints_"
                           + Foam::name(meIndex),
-                            cE, 0, false, true
+                            labelList(cE), 0, false, true
                         );
 
                         Pout<< " Failed to match edge: "
                             << meIndex << " :: " << edges_[meIndex]
                             << " using comparison edge: " << cE
                             << " on proc: " << procIndices_[pI]
-                            << abort(FatalError);
+                            << endl;
                     }
                 }
             }
         }
+
+        // Ensure that all entities were matched
+        label nFailFace = 0, nFailEdge = 0;
+
+        forAll(matchedFaces, faceI)
+        {
+            if (!matchedFaces[faceI])
+            {
+                ++nFailFace;
+            }
+        }
+
+        forAll(matchedEdges, edgeI)
+        {
+            if (!matchedEdges[edgeI])
+            {
+                ++nFailEdge;
+            }
+        }
+
+        if (nFailFace || nFailEdge)
+        {
+            Pout<< " Failed to match all entities. " << nl
+                << "  Faces: " << nFailFace << nl
+                << "  Edges: " << nFailEdge << nl
+                << abort(FatalError);
+        }
     }
 
     // Set the flag
     topoChangeFlag_ = true;
 
     // Increment the counter
-    statistics_[4]++;
+    status(TOTAL_COLLAPSES)++;
 
     // Increment the number of modifications
-    statistics_[0]++;
+    status(TOTAL_MODIFICATIONS)++;
 
     // Return a succesful collapse
     map.type() = collapseCase;
@@ -7168,7 +7607,7 @@ const changeMap dynamicTopoFvMesh::removeCellLayer
     forAllConstIter(Map<labelPair>, pointsToRemove, pIter)
     {
         // Update pointEdges information first
-        if (!twoDMesh_)
+        if (is3D())
         {
             const labelList& pEdges = pointEdges_[pIter.key()];
 
@@ -7311,7 +7750,7 @@ const changeMap dynamicTopoFvMesh::removeCellLayer
         setCellMapping
         (
             cellsToRemove[indexI].second(),
-            cellsToRemove[indexI]
+            labelList(cellsToRemove[indexI])
         );
     }
 
@@ -7446,13 +7885,11 @@ const changeMap dynamicTopoFvMesh::mergeBoundaryFaces
                 -1,
                 face(faces_[retainedFace]),
                 newOwner,
-                newNeighbour
+                newNeighbour,
+                labelList(faceEdges_[retainedFace])
             )
         );
 
-        // Add the faceEdges entry
-        faceEdges_.append(labelList(faceEdges_[retainedFace]));
-
         // Update map
         map.addFace(newFaceIndex);
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
index 3a5887a9c..2b732ef61 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
@@ -160,7 +160,7 @@ bool dynamicTopoFvMesh::testDelaunay
         forAll(procIndices_, pI)
         {
             // Fetch non-const reference to subMeshes
-            const coupledInfo& recvMesh = recvMeshes_[pI];
+            const coupledMesh& recvMesh = recvMeshes_[pI];
 
             const coupleMap& cMap = recvMesh.map();
             const dynamicTopoFvMesh& sMesh = recvMesh.subMesh();
@@ -1073,7 +1073,7 @@ const changeMap dynamicTopoFvMesh::swapQuadFace
     topoChangeFlag_ = true;
 
     // Increment the counter
-    statistics_[1]++;
+    status(TOTAL_SWAPS)++;
 
     // Return a successful operation.
     map.type() = 1;
@@ -1853,7 +1853,7 @@ const changeMap dynamicTopoFvMesh::removeEdgeFlips
     map.removeEdge(eIndex);
 
     // Increment the counter
-    statistics_[1]++;
+    status(TOTAL_SWAPS)++;
 
     // Set the flag
     topoChangeFlag_ = true;
@@ -2337,7 +2337,7 @@ const changeMap dynamicTopoFvMesh::swap23
 
         if (debug > 2)
         {
-            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " On SubMesh: " << isSubMesh_ << nl;
             Pout<< " coupledModification: " << coupledModification_ << nl;
 
             label bPatch = whichEdgePatch(eIndex);
@@ -2379,7 +2379,7 @@ const changeMap dynamicTopoFvMesh::swap23
               + "_beforeSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                cellsForRemoval,
+                labelList(cellsForRemoval),
                 3, false, true
             );
         }
@@ -2487,7 +2487,8 @@ const changeMap dynamicTopoFvMesh::swap23
             -1,
             tmpTriFace,
             newCellIndex[0],
-            newCellIndex[1]
+            newCellIndex[1],
+            labelList(0)
         )
     );
 
@@ -2509,7 +2510,8 @@ const changeMap dynamicTopoFvMesh::swap23
             -1,
             tmpTriFace,
             newCellIndex[1],
-            newCellIndex[2]
+            newCellIndex[2],
+            labelList(0)
         )
     );
 
@@ -2528,19 +2530,14 @@ const changeMap dynamicTopoFvMesh::swap23
             -1,
             tmpTriFace,
             newCellIndex[0],
-            newCellIndex[2]
+            newCellIndex[2],
+            labelList(0)
         )
     );
 
     // Add this face to the map.
     map.addFace(newFaceIndex[2]);
 
-    // Append three dummy faceEdges entries.
-    for (label i = 0; i < 3; i++)
-    {
-        faceEdges_.append(labelList(0));
-    }
-
     // Add an entry to edgeFaces
     labelList newEdgeFaces(3);
     newEdgeFaces[0] = newFaceIndex[0];
@@ -2901,7 +2898,7 @@ const changeMap dynamicTopoFvMesh::swap23
               + "_afterSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                newCellIndex,
+                labelList(newCellIndex),
                 3, false, true
             );
         }
@@ -2996,7 +2993,7 @@ const changeMap dynamicTopoFvMesh::swap32
 
         if (debug > 2)
         {
-            Pout<< " On SubMesh: " << Switch::asText(isSubMesh_) << nl;
+            Pout<< " On SubMesh: " << isSubMesh_ << nl;
             Pout<< " coupledModification: " << coupledModification_ << nl;
 
             label bPatch = whichEdgePatch(eIndex);
@@ -3082,7 +3079,8 @@ const changeMap dynamicTopoFvMesh::swap32
             -1,
             newTriFace,
             newCellIndex[0],
-            newCellIndex[1]
+            newCellIndex[1],
+            labelList(3, -1)
         )
     );
 
@@ -3092,9 +3090,6 @@ const changeMap dynamicTopoFvMesh::swap32
     // Note the triangulation face in index()
     map.index() = newFaceIndex;
 
-    // Add faceEdges for the new face as well.
-    faceEdges_.append(labelList(3));
-
     // Define the three edges to check while building faceEdges:
     FixedList<edge,3> check;
 
@@ -3208,7 +3203,8 @@ const changeMap dynamicTopoFvMesh::swap32
                 facePatch,
                 newBdyTriFace[0],
                 newCellIndex[1],
-                -1
+                -1,
+                labelList(3, -1)
             )
         );
 
@@ -3223,7 +3219,8 @@ const changeMap dynamicTopoFvMesh::swap32
                 facePatch,
                 newBdyTriFace[1],
                 newCellIndex[0],
-                -1
+                -1,
+                labelList(3, -1)
             )
         );
 
@@ -3286,11 +3283,11 @@ const changeMap dynamicTopoFvMesh::swap32
         }
 
         // Add faceEdges for the two new boundary faces
-        faceEdges_.append(bdyFaceEdges[0]);
-        faceEdges_.append(bdyFaceEdges[1]);
+        faceEdges_[newBdyFaceIndex[0]] = bdyFaceEdges[0];
+        faceEdges_[newBdyFaceIndex[1]] = bdyFaceEdges[1];
 
         // Update the number of surface swaps.
-        statistics_[2]++;
+        status(SURFACE_SWAPS)++;
     }
 
     newTetCell[0][nF0++] = newFaceIndex;
@@ -3520,7 +3517,7 @@ const changeMap dynamicTopoFvMesh::swap32
               + "_afterSwap_"
               + Foam::name(numTriangulations) + "_"
               + Foam::name(triangulationIndex),
-                newCellIndex,
+                labelList(newCellIndex),
                 3, false, true
             );
         }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
index 0b693e259..5bfbd07e5 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/conservativeMapFields.H
@@ -76,7 +76,7 @@ void conservativeMapVolFields(const topoMapper& mapper)
         // Map patch fields
         forAll(bMap, patchI)
         {
-            bMap[patchI].mapPatchField
+            bMap[patchI].mapFvPatchField
             (
                 field.name(),
                 field.boundaryField()[patchI]
@@ -131,7 +131,7 @@ void conservativeMapSurfaceFields(const topoMapper& mapper)
         // Map patch fields
         forAll(bMap, patchI)
         {
-            bMap[patchI].mapPatchField
+            bMap[patchI].mapFvsPatchField
             (
                 field.name(),
                 field.boundaryField()[patchI]
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
index 6f360e8e4..4d2f6ecb8 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
@@ -90,7 +90,7 @@ autoPtr<fluxCorrector> fluxCorrector::New
             )   << "Unknown fluxCorrector type " << correctorTypeName
                 << endl << endl
                 << "Valid fluxCorrector types are: " << endl
-                << meshConstructorTablePtr_->sortedToc()
+                << meshConstructorTablePtr_->toc()
                 << exit(FatalError);
         }
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
index 0ec426df8..88049de37 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
@@ -39,7 +39,6 @@ Author
 #include "topoCellMapper.H"
 #include "topoSurfaceMapper.H"
 #include "topoBoundaryMeshMapper.H"
-#include "fixedValueFvPatchFields.H"
 
 namespace Foam
 {
@@ -49,13 +48,14 @@ namespace Foam
 //- Store gradients prior to mesh reset
 void topoMapper::storeGradients() const
 {
-    storeGradients<scalar>(sGrads_);
-    storeGradients<vector>(vGrads_);
+    // Go in order of highest to lowest rank,
+    // to avoid double storage
+    storeGradients<vector>(gradTable_, vGradPtrs_);
+    storeGradients<scalar>(gradTable_, sGradPtrs_);
 
     if (fvMesh::debug)
     {
-        Info<< "Registered volScalarFields: " << scalarGrads() << endl;
-        Info<< "Registered volVectorFields: " << vectorGrads() << endl;
+        Info<< "Registered gradients: " << gradientTable() << endl;
     }
 }
 
@@ -63,6 +63,10 @@ void topoMapper::storeGradients() const
 //- Store geometric information
 void topoMapper::storeGeometry() const
 {
+    typedef volVectorField::PatchFieldType PatchFieldType;
+    typedef volVectorField::GeometricBoundaryField GeomBdyFieldType;
+    typedef volVectorField::DimensionedInternalField DimInternalField;
+
     // Wipe out existing information
     deleteDemandDrivenData(cellCentresPtr_);
 
@@ -73,26 +77,41 @@ void topoMapper::storeGeometry() const
     label nPatches = mesh_.boundary().size();
 
     // Create field parts
-    PtrList<fvPatchField<vector> > volCentrePatches(nPatches);
+    PtrList<PatchFieldType> volCentrePatches(nPatches);
 
-    // Over-ride and set all patches to fixedValue
-    for (label patchI = 0; patchI < nPatches; patchI++)
+    // Define patch type names
+    word emptyType("empty");
+    word fixedValueType("fixedValue");
+
+    // Create dummy types for initial field creation
+    forAll(volCentrePatches, patchI)
     {
-        volCentrePatches.set
-        (
-            patchI,
-            new fixedValueFvPatchField<vector>
+        if (mesh_.boundary()[patchI].type() == emptyType)
+        {
+            volCentrePatches.set
             (
-                mesh_.boundary()[patchI],
-                DimensionedField<vector, volMesh>::null()
-            )
-        );
-
-        // Slice field to patch (forced assignment)
-        volCentrePatches[patchI] ==
-        (
-            mesh_.boundaryMesh()[patchI].patchSlice(Cf)
-        );
+                patchI,
+                PatchFieldType::New
+                (
+                    emptyType,
+                    mesh_.boundary()[patchI],
+                    DimInternalField::null()
+                )
+            );
+        }
+        else
+        {
+            volCentrePatches.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    fixedValueType,
+                    mesh_.boundary()[patchI],
+                    DimInternalField::null()
+                )
+            );
+        }
     }
 
     // Set the cell-centres pointer.
@@ -107,7 +126,7 @@ void topoMapper::storeGeometry() const
                 mesh_,
                 IOobject::NO_READ,
                 IOobject::NO_WRITE,
-                false
+                true
             ),
             mesh_,
             dimLength,
@@ -115,6 +134,48 @@ void topoMapper::storeGeometry() const
             volCentrePatches
         )
     );
+
+    // Alias for convenience
+    volVectorField& centres = *cellCentresPtr_;
+
+    // Set correct references for patch internal fields
+    GeomBdyFieldType& bf = centres.boundaryField();
+
+    forAll(bf, patchI)
+    {
+        if (mesh_.boundary()[patchI].type() == emptyType)
+        {
+            bf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    emptyType,
+                    mesh_.boundary()[patchI],
+                    centres.dimensionedInternalField()
+                )
+            );
+        }
+        else
+        {
+            bf.set
+            (
+                patchI,
+                PatchFieldType::New
+                (
+                    fixedValueType,
+                    mesh_.boundary()[patchI],
+                    centres.dimensionedInternalField()
+                )
+            );
+
+            // Slice field to patch (forced assignment)
+            bf[patchI] == mesh_.boundaryMesh()[patchI].patchSlice(Cf);
+        }
+    }
+
+    // Set the cell-volumes pointer
+    cellVolumesPtr_ = new scalarField(mesh_.cellVolumes());
 }
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
@@ -132,6 +193,7 @@ topoMapper::topoMapper
     surfaceMap_(NULL),
     boundaryMap_(NULL),
     fluxCorrector_(fluxCorrector::New(mesh, dict)),
+    cellVolumesPtr_(NULL),
     cellCentresPtr_(NULL)
 {}
 
@@ -339,6 +401,22 @@ const vectorField& topoMapper::internalCentres() const
 }
 
 
+//- Return non-const access to cell volumes
+scalarField& topoMapper::internalVolumes() const
+{
+    if (!cellVolumesPtr_)
+    {
+        FatalErrorIn
+        (
+            "scalarField& topoMapper::internalVolumes() const"
+        ) << nl << " Pointer has not been set. "
+          << abort(FatalError);
+    }
+
+    return *cellVolumesPtr_;
+}
+
+
 //- Return stored patch centre information
 const vectorField& topoMapper::patchCentres(const label i) const
 {
@@ -356,17 +434,10 @@ const vectorField& topoMapper::patchCentres(const label i) const
 }
 
 
-//- Return names of stored scalar gradients
-const wordList topoMapper::scalarGrads() const
+//- Return names of stored gradients
+const wordList topoMapper::gradientTable() const
 {
-    return sGrads_.toc();
-}
-
-
-//- Return names of stored vector gradients
-const wordList topoMapper::vectorGrads() const
-{
-    return vGrads_.toc();
+    return gradTable_.toc();
 }
 
 
@@ -374,7 +445,7 @@ const wordList topoMapper::vectorGrads() const
 template <>
 volVectorField& topoMapper::gradient(const word& name) const
 {
-    if (!sGrads_.found(name))
+    if (!gradTable_.found(name))
     {
         FatalErrorIn
         (
@@ -384,7 +455,7 @@ volVectorField& topoMapper::gradient(const word& name) const
           << abort(FatalError);
     }
 
-    return sGrads_[name]();
+    return sGradPtrs_[gradTable_[name].second()];
 }
 
 
@@ -392,7 +463,7 @@ volVectorField& topoMapper::gradient(const word& name) const
 template <>
 volTensorField& topoMapper::gradient(const word& name) const
 {
-    if (!vGrads_.found(name))
+    if (!gradTable_.found(name))
     {
         FatalErrorIn
         (
@@ -402,7 +473,28 @@ volTensorField& topoMapper::gradient(const word& name) const
           << abort(FatalError);
     }
 
-    return vGrads_[name]();
+    return vGradPtrs_[gradTable_[name].second()];
+}
+
+
+//- Deregister gradient fields and centres,
+//  but retain for mapping
+void topoMapper::deregisterMeshInformation() const
+{
+    // Check out scalar gradients
+    forAll(sGradPtrs_, fieldI)
+    {
+        mesh_.objectRegistry::checkOut(sGradPtrs_[fieldI]);
+    }
+
+    // Check out vector gradients
+    forAll(vGradPtrs_, fieldI)
+    {
+        mesh_.objectRegistry::checkOut(vGradPtrs_[fieldI]);
+    }
+
+    // Check out cell centres
+    mesh_.objectRegistry::checkOut(*cellCentresPtr_);
 }
 
 
@@ -495,11 +587,15 @@ void topoMapper::clear() const
     surfaceMap_.clear();
     boundaryMap_.clear();
 
+    // Clear index maps
+    gradTable_.clear();
+
     // Clear stored gradients
-    sGrads_.clear();
-    vGrads_.clear();
+    sGradPtrs_.clear();
+    vGradPtrs_.clear();
 
     // Wipe out geomtry information
+    deleteDemandDrivenData(cellVolumesPtr_);
     deleteDemandDrivenData(cellCentresPtr_);
 
     // Clear maps
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
index 40e96e245..3e99e4757 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
@@ -41,7 +41,9 @@ SourceFiles
 #ifndef topoMapper_H
 #define topoMapper_H
 
+#include "Tuple2.H"
 #include "autoPtr.H"
+#include "PtrList.H"
 #include "IOmanip.H"
 #include "volFields.H"
 
@@ -62,6 +64,11 @@ class topoBoundaryMeshMapper;
 
 class topoMapper
 {
+    // Private typedefs
+
+        typedef Tuple2<word, label> GradientMap;
+        typedef HashTable<GradientMap> GradientTable;
+
     // Private data
 
         //- Reference to fvMesh
@@ -84,11 +91,15 @@ class topoMapper
         //- Flux corrector
         mutable autoPtr<fluxCorrector> fluxCorrector_;
 
+        // Index map for gradients
+        mutable GradientTable gradTable_;
+
         // Stored gradients for mapping
-        mutable HashTable<autoPtr<volVectorField> > sGrads_;
-        mutable HashTable<autoPtr<volTensorField> > vGrads_;
+        mutable PtrList<volVectorField> sGradPtrs_;
+        mutable PtrList<volTensorField> vGradPtrs_;
 
         //- Geometric information on the old mesh
+        mutable scalarField* cellVolumesPtr_;
         mutable volVectorField* cellCentresPtr_;
 
         //- Intersection weights
@@ -120,7 +131,8 @@ class topoMapper
         template <class Type, class gradType>
         void storeGradients
         (
-            HashTable<autoPtr<gradType> >& gradTable
+            GradientTable& gradTable,
+            PtrList<gradType>& gradList
         ) const;
 
         //- Store gradients prior to mesh reset
@@ -209,20 +221,24 @@ public:
         //- Store mesh information for the mapping stage
         void storeMeshInformation() const;
 
+        //- Deregister gradient fields and centres,
+        //  but retain for mapping
+        void deregisterMeshInformation() const;
+
         //- Return non-const access to cell centres
         volVectorField& volCentres() const;
 
+        //- Return non-const access to cell volumes
+        scalarField& internalVolumes() const;
+
         //- Return stored cell centre information
         const vectorField& internalCentres() const;
 
         //- Return stored patch centre information
         const vectorField& patchCentres(const label i) const;
 
-        //- Return names of stored scalar gradients
-        const wordList scalarGrads() const;
-
-        //- Return names of stored vector gradients
-        const wordList vectorGrads() const;
+        //- Return names of stored gradients
+        const wordList gradientTable() const;
 
         //- Fetch the gradient field
         template <class Type>
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
index 8a4adeb4d..41f0469c9 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapperTemplates.C
@@ -35,66 +35,104 @@ namespace Foam
 template <class Type, class gradType>
 void topoMapper::storeGradients
 (
-    HashTable<autoPtr<gradType> >& gradTable
+    GradientTable& gradTable,
+    PtrList<gradType>& gradList
 ) 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;
+    typedef const GeometricField<Type, fvPatchField, volMesh> constVolType;
+
+    typedef HashTable<constVolType*> volTypeTable;
 
     // Fetch all fields from registry
-    HashTable<const volType*> fields
-    (
-        mesh_.objectRegistry::lookupClass<volType>()
-    );
+    volTypeTable fields(mesh_.objectRegistry::lookupClass<volType>());
+
+    // Track field count
+    label nFields = 0;
 
     // Store old-times before gradient computation
-    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    for
+    (
+        typename volTypeTable::iterator fIter = fields.begin();
+        fIter != fields.end();
+        ++fIter
+    )
     {
         fIter()->storeOldTimes();
+        nFields++;
     }
 
-    forAllConstIter(typename HashTable<const volType*>, fields, fIter)
+    // Size up the list
+    gradList.setSize(nFields);
+
+    label fieldIndex = 0;
+
+    for
+    (
+        typename volTypeTable::const_iterator fIter = fields.begin();
+        fIter != fields.end();
+        ++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() + ')');
 
+        // Register field under a name that's unique
+        word registerName("remapGradient(" + field.name() + ')');
+
+        // Make a new entry
         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>
+            gradList.set
             (
+                fieldIndex,
                 new gradType
                 (
                     IOobject
                     (
-                        tGrad().name(),
+                        registerName,
                         mesh_.time().timeName(),
                         mesh_,
                         IOobject::NO_READ,
                         IOobject::NO_WRITE,
-                        false
+                        true
                     ),
-                    tGrad()
+                    fvc::grad(field, gradName)()
                 )
-            )
+            );
+        }
+        else
+        {
+            gradList.set
+            (
+                fieldIndex,
+                new gradType
+                (
+                    IOobject
+                    (
+                        registerName,
+                        mesh_.time().timeName(),
+                        mesh_,
+                        IOobject::NO_READ,
+                        IOobject::NO_WRITE,
+                        true
+                    ),
+                    fv::leastSquaresGrad<Type>(mesh_).grad(field)()
+                )
+            );
+        }
+
+        // Add a map entry
+        gradTable.insert
+        (
+            field.name(),
+            GradientMap(registerName, fieldIndex++)
         );
     }
 }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
index e4ef74f6d..733fa3a2e 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
@@ -313,7 +313,7 @@ void topoPatchMapper::calcAddressing() const
 
         // Do mapped faces. Note that this can already be set by insertedFaces
         // so check if addressing size still zero.
-        const labelList& fm = patch_.patch().patchSlice(mpm_.faceMap());
+        const labelList::subList fm = patch_.patch().patchSlice(mpm_.faceMap());
 
         forAll(fm, faceI)
         {
@@ -367,6 +367,8 @@ void topoPatchMapper::calcAddressing() const
                     continue;
                 }
 
+                label oldFace = (faceI < fm.size() ? fm[faceI] : -1);
+
                 FatalErrorIn
                 (
                     "void topoPatchMapper::calcAddressing() const"
@@ -374,8 +376,11 @@ void topoPatchMapper::calcAddressing() const
                     << "Addressing is missing." << nl
                     << " Patch face index: " << faceI << nl
                     << " nInsertedFaces: " << insertedFaces.size() << nl
-                    << " faceMap: " << fm[faceI] << nl
+                    << " faceMap[faceI]: " << oldFace << nl
+                    << " patch faceMap size: " << fm.size() << nl
                     << " Patch: " << patch_.name() << nl
+                    << " polyPatch: " << nl << patch_.patch() << nl
+                    << " faceMap size: " << mpm_.faceMap().size() << nl
                     << abort(FatalError);
             }
         }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
index 6fcf6e84e..5047b18bf 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
@@ -187,10 +187,18 @@ public:
 
         //- Map the patch field
         template <class Type>
-        void mapPatchField
+        void mapFvPatchField
         (
             const word& fieldName,
-            Field<Type>& pF
+            fvPatchField<Type>& pF
+        ) const;
+
+        //- Map the patch field
+        template <class Type>
+        void mapFvsPatchField
+        (
+            const word& fieldName,
+            fvsPatchField<Type>& pF
         ) const;
 };
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
index bb8b78894..51b20a316 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapperTemplates.C
@@ -32,15 +32,49 @@ namespace Foam
 
 //- Map the patch field
 template <class Type>
-void topoPatchMapper::mapPatchField
+void topoPatchMapper::mapFvPatchField
 (
     const word& fieldName,
-    Field<Type>& pF
+    fvPatchField<Type>& pF
 ) const
 {
     // Specify that mapping is conservative
     conservative_ = true;
 
+    if (fvMesh::debug)
+    {
+        Pout<< " Field: " << fieldName
+            << " Mapping patch: " << pF.patch().name()
+            << " size: " << this->size()
+            << " sizeBeforeMapping: " << this->sizeBeforeMapping()
+            << endl;
+    }
+
+    // Map patchField onto itself
+    pF.autoMap(*this);
+}
+
+
+//- Map the patch field
+template <class Type>
+void topoPatchMapper::mapFvsPatchField
+(
+    const word& fieldName,
+    fvsPatchField<Type>& pF
+) const
+{
+    // Specify that mapping is conservative
+    conservative_ = true;
+
+    if (fvMesh::debug)
+    {
+        Pout<< " Field: " << fieldName
+            << " Mapping patch: " << pF.patch().name()
+            << " size: " << this->size()
+            << " sizeBeforeMapping: " << this->sizeBeforeMapping()
+            << endl;
+    }
+
     // Map patchField onto itself
     pF.autoMap(*this);
 }
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.C
index a9cb09a54..3d8a81b81 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.C
@@ -34,6 +34,7 @@ Author
 
 \*----------------------------------------------------------------------------*/
 
+#include "fvc.H"
 #include "volFields.H"
 #include "lengthScaleEstimator.H"
 #include "processorPolyPatch.H"
@@ -43,7 +44,14 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(lengthScaleEstimator,0);
+defineTypeNameAndDebug(lengthScaleEstimator, 0);
+
+lengthScaleEstimator::ScaleFnPair lengthScaleEstimator::methods_[] =
+{
+    ScaleFnPair("constant", &lengthScaleEstimator::constantScale),
+    ScaleFnPair("direct", &lengthScaleEstimator::directScale),
+    ScaleFnPair("inverse", &lengthScaleEstimator::inverseScale)
+};
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -66,6 +74,8 @@ lengthScaleEstimator::lengthScaleEstimator
     sliceHoldOff_(0),
     sliceBoxes_(0),
     field_("none"),
+    scale_(NULL),
+    gradient_(false),
     fieldLength_(0.0),
     lowerRefineLevel_(0.001),
     upperRefineLevel_(0.999),
@@ -303,7 +313,7 @@ void lengthScaleEstimator::writeLengthScaleInfo
             // First perform a blocking send/receive of the number of faces.
             OPstream::write
             (
-                Pstream::blocking,
+                Pstream::nonBlocking,
                 neiProcNo,
                 reinterpret_cast<const char*>(&(nSendFaces[pI])),
                 sizeof(label)
@@ -311,7 +321,7 @@ void lengthScaleEstimator::writeLengthScaleInfo
 
             IPstream::read
             (
-                Pstream::blocking,
+                Pstream::nonBlocking,
                 neiProcNo,
                 reinterpret_cast<char*>(&(nRecvFaces[pI])),
                 sizeof(label)
@@ -319,6 +329,10 @@ void lengthScaleEstimator::writeLengthScaleInfo
         }
     }
 
+    // Wait for all transfers to complete.
+    OPstream::waitRequests();
+    IPstream::waitRequests();
+
     // Send info to neighbouring processors.
     forAll(boundary, patchI)
     {
@@ -548,6 +562,69 @@ void lengthScaleEstimator::readLengthScaleInfo
 }
 
 
+// Use a constant length scale for field-based refinement
+scalar lengthScaleEstimator::constantScale(const scalar fieldValue) const
+{
+    return fieldLength_;
+}
+
+
+// Use a direct-proportion length scale for field-based refinement
+scalar lengthScaleEstimator::directScale(const scalar fieldValue) const
+{
+    if (fieldValue > upperRefineLevel_)
+    {
+        return meanScale_;
+    }
+
+    scalar value = fieldValue;
+
+    // Bracket the value within limits
+    value = min(value, upperRefineLevel_);
+    value = max(value, lowerRefineLevel_);
+
+    scalar ratio
+    (
+        (value - lowerRefineLevel_) / (upperRefineLevel_ - lowerRefineLevel_)
+    );
+
+    scalar scale
+    (
+        minLengthScale_ + ((maxLengthScale_ - minLengthScale_) * ratio)
+    );
+
+    return scale;
+}
+
+
+// Use an inverse-proportion length scale for field-based refinement
+scalar lengthScaleEstimator::inverseScale(const scalar fieldValue) const
+{
+    if (fieldValue < lowerRefineLevel_)
+    {
+        return meanScale_;
+    }
+
+    scalar value = fieldValue;
+
+    // Bracket the value within limits
+    value = min(value, upperRefineLevel_);
+    value = max(value, lowerRefineLevel_);
+
+    scalar ratio
+    (
+        (value - lowerRefineLevel_) / (upperRefineLevel_ - lowerRefineLevel_)
+    );
+
+    scalar scale
+    (
+        minLengthScale_ + ((maxLengthScale_ - minLengthScale_) * (1.0 - ratio))
+    );
+
+    return scale;
+}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Read edge refinement options from the dictionary
@@ -764,6 +841,43 @@ void lengthScaleEstimator::readRefinementOptions
     {
         field_ = word(refineDict.lookup("fieldRefinement"));
 
+        word scaleMethod(refineDict.lookup("fieldScaleMethod"));
+
+        const label nMethods(sizeof(methods_) / sizeof(methods_[0]));
+
+        bool invalidMethod = true;
+
+        for (label i = 0; i < nMethods; i++)
+        {
+            if (scaleMethod == methods_[i].first())
+            {
+                scale_ = methods_[i].second();
+                invalidMethod = false;
+                break;
+            }
+        }
+
+        if (invalidMethod)
+        {
+            Info << nl << " Available methods: " << endl;
+
+            for (label i = 0; i < nMethods; i++)
+            {
+                Info << "    " << methods_[i].first() << nl;
+            }
+
+            FatalErrorIn
+            (
+                "void lengthScaleEstimator::readRefinementOptions"
+                "(const dictionary&, bool, bool)"
+            )
+                << " Invalid method: " << scaleMethod << " specified." << nl
+                << abort(FatalError);
+        }
+
+        // Define whether the gradient must be evaluated
+        gradient_ = readBool(refineDict.lookup("fieldGradient"));
+
         // Lookup a specified length-scale
         fieldLength_ = readScalar(refineDict.lookup("fieldLengthScale"));
 
@@ -799,7 +913,7 @@ void lengthScaleEstimator::readRefinementOptions
 }
 
 
-//- Set explicitly coupled patch information
+// Set explicitly coupled patch information
 void lengthScaleEstimator::setCoupledPatches
 (
     const dictionary& coupledPatches
@@ -844,7 +958,7 @@ void lengthScaleEstimator::setCoupledPatches
 }
 
 
-//- Calculate the length scale field
+// Calculate the length scale field
 void lengthScaleEstimator::calculateLengthScale
 (
     UList<scalar>& lengthScale
@@ -915,10 +1029,102 @@ void lengthScaleEstimator::calculateLengthScale
     // If a field has been specified, use that.
     if (field_ != "none")
     {
-        const volScalarField& vFld =
-        (
-            mesh_.objectRegistry::lookupObject<volScalarField>(field_)
-        );
+        const volScalarField* vFldPtr = NULL;
+
+        // Temporary pointer for gradient
+        volScalarField* magGradPtr = NULL;
+
+        if (gradient_)
+        {
+            // Lookup various field types, and evaluate the gradient
+            bool invalidObject = true;
+
+            // Evaluate using gradient scheme
+            word gradName("grad(" + field_ + ')');
+
+            // Register field under a name that's unique
+            word registerName("lengthScaleGradient(" + field_ + ')');
+
+            if (mesh_.objectRegistry::foundObject<volScalarField>(field_))
+            {
+                const volScalarField& field =
+                (
+                    mesh_.objectRegistry::lookupObject<volScalarField>(field_)
+                );
+
+                magGradPtr =
+                (
+                    new volScalarField
+                    (
+                        IOobject
+                        (
+                            registerName,
+                            mesh_.time().timeName(),
+                            mesh_,
+                            IOobject::NO_READ,
+                            IOobject::NO_WRITE,
+                            false
+                        ),
+                        mag(fvc::grad(field, gradName))
+                    )
+                );
+
+                invalidObject = false;
+            }
+
+            if (mesh_.objectRegistry::foundObject<volVectorField>(field_))
+            {
+                const volVectorField& field =
+                (
+                    mesh_.objectRegistry::lookupObject<volVectorField>(field_)
+                );
+
+                magGradPtr =
+                (
+                    new volScalarField
+                    (
+                        IOobject
+                        (
+                            registerName,
+                            mesh_.time().timeName(),
+                            mesh_,
+                            IOobject::NO_READ,
+                            IOobject::NO_WRITE,
+                            false
+                        ),
+                        mag(fvc::grad(field, gradName))
+                    )
+                );
+
+                invalidObject = false;
+            }
+
+            if (invalidObject)
+            {
+                FatalErrorIn
+                (
+                    "void lengthScaleEstimator::calculateLengthScale"
+                    "(UList<scalar>& lengthScale)"
+                )
+                    << " Invalid field: " << field_
+                    << " specified for gradient." << nl
+                    << abort(FatalError);
+            }
+
+            vFldPtr = magGradPtr;
+        }
+        else
+        {
+            // Lookup a scalar field by default
+            const volScalarField& field =
+            (
+                mesh_.objectRegistry::lookupObject<volScalarField>(field_)
+            );
+
+            vFldPtr = &field;
+        }
+
+        const volScalarField& vFld = *vFldPtr;
 
         const labelList& own = mesh_.faceOwner();
         const labelList& nei = mesh_.faceNeighbour();
@@ -935,7 +1141,7 @@ void lengthScaleEstimator::calculateLengthScale
                 if (!cellLevels[ownCell])
                 {
                     cellLevels[ownCell] = level;
-                    lengthScale[ownCell] = fieldLength_;
+                    lengthScale[ownCell] = (this->*scale_)(fAvg);
 
                     levelCells.insert(ownCell);
 
@@ -945,7 +1151,7 @@ void lengthScaleEstimator::calculateLengthScale
                 if (!cellLevels[neiCell])
                 {
                     cellLevels[neiCell] = level;
-                    lengthScale[neiCell] = fieldLength_;
+                    lengthScale[neiCell] = (this->*scale_)(fAvg);
 
                     levelCells.insert(neiCell);
 
@@ -953,6 +1159,12 @@ void lengthScaleEstimator::calculateLengthScale
                 }
             }
         }
+
+        // Clean up gradient, if necessary
+        if (gradient_)
+        {
+            deleteDemandDrivenData(magGradPtr);
+        }
     }
 
     bool doneWithSweeps = false;
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.H
index eb8a33813..da3b2cb8b 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.H
@@ -43,6 +43,7 @@ SourceFiles
 #ifndef lengthScaleEstimator_H
 #define lengthScaleEstimator_H
 
+#include "Tuple2.H"
 #include "polyMesh.H"
 #include "dictionary.H"
 
@@ -108,8 +109,14 @@ class lengthScaleEstimator
         //  are to be avoided
         labelList noModPatchIDs_;
 
+        //- Typedefs for field refinement function pointers
+        typedef scalar (lengthScaleEstimator::*ScaleFn)(const scalar) const;
+        typedef Tuple2<const char*, ScaleFn> ScaleFnPair;
+
         //- Field-based refinement
         word field_;
+        ScaleFn scale_;
+        bool gradient_;
         scalar fieldLength_;
         scalar lowerRefineLevel_;
         scalar upperRefineLevel_;
@@ -118,6 +125,9 @@ class lengthScaleEstimator
         scalar meanScale_;
         label maxRefineLevel_;
 
+        //- Function pointers for scale methods
+        static ScaleFnPair methods_[];
+
     // Private Member Functions
 
         // Check for legitimacy of patches
@@ -153,9 +163,19 @@ class lengthScaleEstimator
             labelHashSet& levelCells
         ) const;
 
+        // Use a constant length scale for field-based refinement
+        scalar constantScale(const scalar fieldValue) const;
+
+        // Use a direct-proportion length scale for field-based refinement
+        scalar directScale(const scalar fieldValue) const;
+
+        // Use an inverse-proportion length scale for field-based refinement
+        scalar inverseScale(const scalar fieldValue) const;
+
 public:
 
     // Declare the name of the class and its debug switch
+
         TypeName("lengthScaleEstimator");
 
     // Constructors
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
index 56e257be7..eb82d247a 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
@@ -34,17 +34,15 @@ Author
 
 \*---------------------------------------------------------------------------*/
 
-#include "objectRegistry.H"
 #include "Time.H"
 #include "meshOps.H"
 #include "ListOps.H"
 #include "Pstream.H"
 #include "triFace.H"
 #include "IOmanip.H"
-#include "HashSet.H"
 #include "polyMesh.H"
+#include "OFstream.H"
 #include "triPointRef.H"
-#include "tetPointRef.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -56,7 +54,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 +124,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,
@@ -333,7 +331,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,
@@ -463,13 +461,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,
@@ -847,7 +879,7 @@ void writeVTK
 
 
 // Actual routine to write out the VTK file
-void writeVTK
+inline void writeVTK
 (
     const polyMesh& mesh,
     const word& name,
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
index 5bb0c2600..7f40d8834 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
@@ -33,8 +33,8 @@ Author
     All rights reserved
 
 SourceFiles
+    meshOpsI.H
     meshOps.C
-    meshOpsTemplates.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -93,7 +93,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 +107,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,
@@ -181,7 +181,7 @@ namespace meshOps
     );
 
     // Dijkstra's algorithm for the shortest path problem
-    bool Dijkstra
+    inline bool Dijkstra
     (
         const Map<point>& points,
         const Map<edge>& edges,
@@ -235,7 +235,8 @@ namespace meshOps
     inline void pWrite
     (
         const label toID,
-        const label& data
+        const label& data,
+        bool blocking = true
     );
 
     // Parallel send (for fixed lists)
@@ -258,7 +259,8 @@ namespace meshOps
     inline void pRead
     (
         const label fromID,
-        label& data
+        label& data,
+        bool blocking = true
     );
 
     // Parallel receive (for fixed lists)
@@ -282,7 +284,7 @@ namespace meshOps
 
     // Select a list of elements from connectivity,
     // and output to a VTK format
-    void writeVTK
+    inline void writeVTK
     (
         const polyMesh& mesh,
         const word& name,
@@ -299,7 +301,7 @@ namespace meshOps
     );
 
     // Actual routine to write out the VTK file
-    void writeVTK
+    inline void writeVTK
     (
         const polyMesh& mesh,
         const word& name,
@@ -320,6 +322,23 @@ namespace meshOps
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// Add additional operations missing in ops.H
+template<class T>
+class lessOp
+{ public: T operator()(const T& x, const T& y) const { return x < y; } };
+
+template<class T>
+class lessEqOp
+{ public: T operator()(const T& x, const T& y) const { return x <= y; } };
+
+template<class T>
+class greaterOp
+{ public: T operator()(const T& x, const T& y) const { return x > y; } };
+
+template<class T>
+class greaterEqOp
+{ public: T operator()(const T& x, const T& y) const { return x >= y; } };
+
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -327,7 +346,7 @@ namespace meshOps
 #include "meshOpsI.H"
 
 #ifdef NoRepository
-#    include "meshOpsTemplates.C"
+#    include "meshOps.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
index 119e6847d..9aaf57ed3 100644
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
@@ -462,12 +462,13 @@ inline bool pointInTriFace
 inline void pWrite
 (
     const label toID,
-    const label& data
+    const label& data,
+    bool blocking
 )
 {
     OPstream::write
     (
-        Pstream::blocking,
+        (blocking ? Pstream::blocking : Pstream::nonBlocking),
         toID,
         reinterpret_cast<const char*>(&data),
         sizeof(label)
@@ -479,12 +480,13 @@ inline void pWrite
 inline void pRead
 (
     const label fromID,
-    label& data
+    label& data,
+    bool blocking
 )
 {
     IPstream::read
     (
-        Pstream::blocking,
+        (blocking ? Pstream::blocking : Pstream::nonBlocking),
         fromID,
         reinterpret_cast<char*>(&data),
         sizeof(label)
@@ -492,6 +494,79 @@ inline void pRead
 }
 
 
+// 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())
@@ -588,6 +663,76 @@ inline void replaceLabel
 }
 
 
+// Utility method to size-up the list to include an item
+template <class Type>
+inline void sizeUpList
+(
+    const Type& item,
+    List<Type>& list
+)
+{
+    list.setSize(list.size() + 1, item);
+}
+
+
+// Utility method to size-down the list to remove an item
+template <class Type>
+inline void sizeDownList
+(
+    const Type& item,
+    List<Type>& list
+)
+{
+    label index = -1;
+
+    if ((index = findIndex(list, item)) > -1)
+    {
+        meshOps::removeIndex(index, list);
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "inline void meshOps::sizeDownList"
+            "(const Type& item, List<Type>& list)"
+        )
+            << nl << "Item: " << item
+            << " was not found in list. " << nl
+            << " List: " << nl << list
+            << abort(FatalError);
+    }
+}
+
+
+// Remove an item at a particular index in the list
+template <class Type>
+inline void removeIndex
+(
+    const label index,
+    List<Type>& list
+)
+{
+    // Create a new list
+    List<Type> newList(list.size() - 1);
+
+    // Copy individual items
+    label n = 0;
+
+    forAll(list, itemI)
+    {
+        if (itemI == index)
+        {
+            continue;
+        }
+
+        newList[n++] = list[itemI];
+    }
+
+    // Overwrite
+    list.transfer(newList);
+}
+
+
 } // End namespace meshOps
 
 
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsTemplates.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsTemplates.C
deleted file mode 100644
index e676c8f59..000000000
--- a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsTemplates.C
+++ /dev/null
@@ -1,195 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | foam-extend: Open Source CFD
-   \\    /   O peration     |
-    \\  /    A nd           | For copyright notice see file Copyright
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of foam-extend.
-
-    foam-extend is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by the
-    Free Software Foundation, either version 3 of the License, or (at your
-    option) any later version.
-
-    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    meshOps
-
-Description
-    Various utility functions that perform mesh-related operations.
-
-Author
-    Sandeep Menon
-    University of Massachusetts Amherst
-    All rights reserved
-
-\*---------------------------------------------------------------------------*/
-
-#include "Pair.H"
-#include "meshOps.H"
-#include "ListOps.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-namespace meshOps
-{
-// 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)
-    );
-}
-
-
-// Utility method to size-up the list to include an item
-template <class Type>
-inline void sizeUpList
-(
-    const Type& item,
-    List<Type>& list
-)
-{
-    list.setSize(list.size() + 1, item);
-}
-
-
-// Utility method to size-down the list to remove an item
-template <class Type>
-inline void sizeDownList
-(
-    const Type& item,
-    List<Type>& list
-)
-{
-    label index = -1;
-
-    if ((index = findIndex(list, item)) > -1)
-    {
-        meshOps::removeIndex(index, list);
-    }
-    else
-    {
-        FatalErrorIn
-        (
-            "inline void meshOps::sizeDownList"
-            "(const Type& item, List<Type>& list)"
-        )
-            << nl << "Item: " << item
-            << " was not found in list. " << nl
-            << " List: " << nl << list
-            << abort(FatalError);
-    }
-}
-
-
-// Remove an item at a particular index in the list
-template <class Type>
-inline void removeIndex
-(
-    const label index,
-    List<Type>& list
-)
-{
-    // Create a new list
-    List<Type> newList(list.size() - 1);
-
-    // Copy individual items
-    label n = 0;
-
-    forAll(list, itemI)
-    {
-        if (itemI == index)
-        {
-            continue;
-        }
-
-        newList[n++] = list[itemI];
-    }
-
-    // Overwrite
-    list.transfer(newList);
-}
-
-
-} // End namespace meshOps
-
-
-} // End namespace Foam
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.C b/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.C
index 6196a4adc..828b94ec3 100644
--- a/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.C
+++ b/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.C
@@ -33,6 +33,7 @@ License
 #include "addToRunTimeSelectionTable.H"
 #include "polyMesh.H"
 
+#include "tetPointRef.H"
 #include "matchPoints.H"
 #include "DimensionedField.H"
 #include "pointPatchField.H"
@@ -68,7 +69,9 @@ mesquiteMotionSolver::mesquiteMotionSolver
     twoDMesh_(mesh.nGeometricD() == 2 ? true : false),
     arraysInitialized_(false),
     nPoints_(mesh.nPoints()),
-    nCells_(mesh.nCells()),
+    nCells_(0),
+    decompType_(-1),
+    nDecompPoints_(0),
     surfaceSmoothing_(false),
     volumeCorrection_(false),
     volCorrTolerance_(1e-20),
@@ -108,7 +111,9 @@ mesquiteMotionSolver::mesquiteMotionSolver
     twoDMesh_(mesh.nGeometricD() == 2 ? true : false),
     arraysInitialized_(false),
     nPoints_(mesh.nPoints()),
-    nCells_(mesh.nCells()),
+    nCells_(0),
+    decompType_(-1),
+    nDecompPoints_(0),
     surfaceSmoothing_(false),
     volumeCorrection_(false),
     volCorrTolerance_(1e-20),
@@ -1131,6 +1136,34 @@ void mesquiteMotionSolver::readOptions()
 
         tcOuter_.add_iteration_limit(1);
     }
+
+    // Set decomposition type, if available
+    if (optionsDict.found("decompType"))
+    {
+        word dType(optionsDict.lookup("decompType"));
+
+        if (dType == "cell")
+        {
+            decompType_ = 1;
+        }
+        else
+        if (dType == "face")
+        {
+            decompType_ = 2;
+        }
+        else
+        {
+            FatalErrorIn("void mesquiteMotionSolver::readOptions()")
+                << "Unknown decomposition type: " << dType
+                << "Available types are: cell or face"
+                << abort(FatalError);
+        }
+    }
+    else
+    {
+        // Set default
+        decompType_ = 2;
+    }
 }
 
 
@@ -1146,6 +1179,7 @@ void mesquiteMotionSolver::initArrays()
         gradEdge_.setSize(pIDs_.size());
         localPts_.setSize(pIDs_.size());
         edgeMarker_.setSize(pIDs_.size());
+        edgeConstant_.setSize(pIDs_.size());
 
         label totalSize = 0;
 
@@ -1158,6 +1192,7 @@ void mesquiteMotionSolver::initArrays()
             localPts_[patchI].setSize(nPts, vector::zero);
             gradEdge_[patchI].setSize(nEdg, vector::zero);
             edgeMarker_[patchI].setSize(nEdg, 1.0);
+            edgeConstant_[patchI].setSize(nEdg, 1.0);
 
             // Accumulate the total size
             totalSize += nPts;
@@ -1178,6 +1213,7 @@ void mesquiteMotionSolver::initArrays()
         // Prepare the boundary condition vectorField
         forAll(pIDs_, patchI)
         {
+            const label pOffset = offsets_[patchI];
             const edgeList& edges = boundary[pIDs_[patchI]].edges();
 
             for
@@ -1187,8 +1223,8 @@ void mesquiteMotionSolver::initArrays()
                 i++
             )
             {
-                bdy_[edges[i][0] + offsets_[patchI]] = vector::zero;
-                bdy_[edges[i][1] + offsets_[patchI]] = vector::zero;
+                bdy_[edges[i][0] + pOffset] = vector::zero;
+                bdy_[edges[i][1] + pOffset] = vector::zero;
             }
         }
 
@@ -1206,37 +1242,75 @@ void mesquiteMotionSolver::initArrays()
         return;
     }
 
+    const dictionary& optionsDict = subDict("mesquiteOptions");
+
+    label nPolyhedra = 0;
+    label nCellPoints = 0, nFacePoints = 0;
+
     // Construct shape recognizers
-    label nUnknown = 0;
     FixedList<label, 4> nTypes(0);
     FixedList<autoPtr<cellMatcher>, 4> matcher;
     FixedList<Mesquite::EntityTopology, 4> cellType;
 
     // Set types
-    matcher[0].set(new hexMatcher());
-    cellType[0] = Mesquite::HEXAHEDRON;
+    bool standardTypes = false;
 
-    matcher[1].set(new tetMatcher());
-    cellType[1] = Mesquite::TETRAHEDRON;
+    if (optionsDict.found("standardCellTypes"))
+    {
+        standardTypes = readBool(optionsDict.lookup("standardCellTypes"));
+    }
 
-    matcher[2].set(new pyrMatcher());
-    cellType[2] = Mesquite::PYRAMID;
+    if (standardTypes)
+    {
+        matcher[0].set(new tetMatcher());
+        cellType[0] = Mesquite::TETRAHEDRON;
 
-    matcher[3].set(new prismMatcher());
-    cellType[3] = Mesquite::PRISM;
+        matcher[1].set(new hexMatcher());
+        cellType[1] = Mesquite::HEXAHEDRON;
+
+        matcher[2].set(new pyrMatcher());
+        cellType[2] = Mesquite::PYRAMID;
+
+        matcher[3].set(new prismMatcher());
+        cellType[3] = Mesquite::PRISM;
+    }
+    else
+    {
+        // No standard types.
+        // Default to tetrahedra, and decompose the rest.
+        matcher[0].set(new tetMatcher());
+        cellType[0] = Mesquite::TETRAHEDRON;
+
+        matcher[1].set(NULL);
+        matcher[2].set(NULL);
+        matcher[3].set(NULL);
+    }
 
     const faceList& meshFaces = mesh().faces();
     const cellList& meshCells = mesh().cells();
     const labelList& faceOwner = mesh().faceOwner();
 
+    // Face marker list
+    List<labelPair> faceMarker;
+
+    if (decompType_ == 2)
+    {
+        faceMarker.setSize(meshFaces.size(), labelPair(-1, -1));
+    }
+
     forAll(meshCells, cellI)
     {
         bool foundMatch = false;
 
         forAll(matcher, indexI)
         {
-            if (matcher[indexI]->isA(mesh(), cellI))
+            if
+            (
+                matcher[indexI].valid() &&
+                matcher[indexI]->isA(mesh(), cellI)
+            )
             {
+                nCells_++;
                 nTypes[indexI]++;
 
                 foundMatch = true;
@@ -1244,43 +1318,126 @@ void mesquiteMotionSolver::initArrays()
             }
         }
 
-        if (!foundMatch)
+        if (foundMatch)
         {
-            nUnknown++;
+            continue;
+        }
+
+        // Assume polyhedron
+        nPolyhedra++;
+
+        // Decompose into tets.
+        const cell& checkCell = meshCells[cellI];
+
+        // Add a central point for the cell
+        nCellPoints++;
+        nDecompPoints_++;
+
+        forAll(checkCell, faceI)
+        {
+            const face& checkFace = meshFaces[checkCell[faceI]];
+
+            switch (decompType_)
+            {
+                case 1:
+                {
+                    nCells_ += (checkFace.size() - 2);
+                    nTypes[0] += (checkFace.size() - 2);
+
+                    break;
+                }
+
+                case 2:
+                {
+                    if (checkFace.size() == 3)
+                    {
+                        nCells_++;
+                        nTypes[0]++;
+                    }
+                    else
+                    {
+                        // Add a central point for the face
+                        labelPair& fPair = faceMarker[checkCell[faceI]];
+
+                        if (fPair.first() == -1)
+                        {
+                            fPair.first() = 1;
+
+                            nFacePoints++;
+                            nDecompPoints_++;
+                        }
+
+                        nCells_ += checkFace.size();
+                        nTypes[0] += checkFace.size();
+                    }
+
+                    break;
+                }
+
+                default:
+                {
+                    FatalErrorIn("void mesquiteMotionSolver::initArrays()")
+                        << "Unknown polyhedron decomposition type."
+                        << abort(FatalError);
+
+                    break;
+                }
+            }
         }
     }
 
     if (debug)
     {
-        Pout<< "nHex     = " << nTypes[0] << nl
-            << "nTet     = " << nTypes[1] << nl
-            << "nPyr     = " << nTypes[2] << nl
-            << "nPrism   = " << nTypes[3] << nl
-            << "nUnknown = " << nUnknown << endl;
+        Pout<< "nTet       = " << nTypes[0] << nl
+            << "nHex       = " << nTypes[1] << nl
+            << "nPyr       = " << nTypes[2] << nl
+            << "nPrism     = " << nTypes[3] << nl
+            << "nPolyhedra = " << nPolyhedra << endl;
     }
 
     label nCellToNode =
     (
-        (8 * nTypes[0])
-      + (4 * nTypes[1])
+        (4 * nTypes[0])
+      + (8 * nTypes[1])
       + (5 * nTypes[2])
       + (6 * nTypes[3])
     );
 
     // Prepare arrays for mesquite
-    vtxCoords_.setSize(3 * nPoints_);
+    vtxCoords_.setSize(3 * (nPoints_ + nDecompPoints_));
     cellToNode_.setSize(nCellToNode);
-    fixFlags_.setSize(nPoints_);
+    fixFlags_.setSize(nPoints_ + nDecompPoints_);
     mixedTypes_.setSize(nCells_);
+    decompCellCentres_.setSize(nCellPoints);
+    decompFaceCentres_.setSize(nFacePoints);
+
+    // Reset faceMarker
+    if (nFacePoints)
+    {
+        forAll(faceMarker, faceI)
+        {
+            faceMarker[faceI].first() = -1;
+        }
+    }
+
+    // Reset counters
+    nDecompPoints_ = 0;
+    nCellPoints = 0, nFacePoints = 0;
 
     // Set connectivity information
     label cIndex = 0, cellIndex = 0;
 
     forAll(meshCells, cellI)
     {
+        bool foundMatch = false;
+
         forAll(matcher, indexI)
         {
-            if (matcher[indexI]->isA(mesh(), cellI))
+            if
+            (
+                matcher[indexI].valid() &&
+                matcher[indexI]->isA(mesh(), cellI)
+            )
             {
                 // Match shape
                 matcher[indexI]->matchShape
@@ -1303,13 +1460,160 @@ void mesquiteMotionSolver::initArrays()
                 // Set element type
                 mixedTypes_[cellIndex++] = cellType[indexI];
 
+                foundMatch = true;
+                break;
+            }
+        }
+
+        if (foundMatch)
+        {
+            continue;
+        }
+
+        // Decompose into tets.
+        const cell& checkCell = meshCells[cellI];
+
+        // Add a central point for the cell
+        label cellPoint = nPoints_ + nDecompPoints_;
+
+        decompCellCentres_[nCellPoints].first() = cellI;
+        decompCellCentres_[nCellPoints].second() = cellPoint;
+
+        nCellPoints++;
+        nDecompPoints_++;
+
+        switch (decompType_)
+        {
+            case 1:
+            {
+                forAll(checkCell, faceI)
+                {
+                    const face& checkFace = meshFaces[checkCell[faceI]];
+                    const label& checkOwner = faceOwner[checkCell[faceI]];
+
+                    if (checkOwner == cellI)
+                    {
+                        for (label nI = (checkFace.size() - 1); nI > 1; nI--)
+                        {
+                            cellToNode_[cIndex++] = checkFace[0];
+                            cellToNode_[cIndex++] = checkFace[nI];
+                            cellToNode_[cIndex++] = checkFace[nI - 1];
+                            cellToNode_[cIndex++] = cellPoint;
+
+                            mixedTypes_[cellIndex++] = cellType[0];
+                        }
+                    }
+                    else
+                    {
+                        for (label nI = 1; nI < (checkFace.size() - 1); nI++)
+                        {
+                            cellToNode_[cIndex++] = checkFace[0];
+                            cellToNode_[cIndex++] = checkFace[nI];
+                            cellToNode_[cIndex++] = checkFace[nI + 1];
+                            cellToNode_[cIndex++] = cellPoint;
+
+                            mixedTypes_[cellIndex++] = cellType[0];
+                        }
+                    }
+                }
+
+                break;
+            }
+
+            case 2:
+            {
+                forAll(checkCell, faceI)
+                {
+                    const face& checkFace = meshFaces[checkCell[faceI]];
+                    const label& checkOwner = faceOwner[checkCell[faceI]];
+
+                    if (checkFace.size() == 3)
+                    {
+                        if (checkOwner == cellI)
+                        {
+                            cellToNode_[cIndex++] = checkFace[2];
+                            cellToNode_[cIndex++] = checkFace[1];
+                            cellToNode_[cIndex++] = checkFace[0];
+                            cellToNode_[cIndex++] = cellPoint;
+
+                            mixedTypes_[cellIndex++] = cellType[0];
+                        }
+                        else
+                        {
+                            cellToNode_[cIndex++] = checkFace[0];
+                            cellToNode_[cIndex++] = checkFace[1];
+                            cellToNode_[cIndex++] = checkFace[2];
+                            cellToNode_[cIndex++] = cellPoint;
+
+                            mixedTypes_[cellIndex++] = cellType[0];
+                        }
+                    }
+                    else
+                    {
+                        // Add a central point for the face
+                        labelPair& fPair = faceMarker[checkCell[faceI]];
+
+                        if (fPair.first() == -1)
+                        {
+                            fPair.first() = checkCell[faceI];
+                            fPair.second() = nPoints_ + nDecompPoints_;
+
+                            nFacePoints++;
+                            nDecompPoints_++;
+                        }
+
+                        if (checkOwner == cellI)
+                        {
+                            forAllReverse(checkFace, nI)
+                            {
+                                cellToNode_[cIndex++] = checkFace[nI];
+                                cellToNode_[cIndex++] = checkFace.prevLabel(nI);
+                                cellToNode_[cIndex++] = fPair.second();
+                                cellToNode_[cIndex++] = cellPoint;
+
+                                mixedTypes_[cellIndex++] = cellType[0];
+                            }
+                        }
+                        else
+                        {
+                            forAll(checkFace, nI)
+                            {
+                                cellToNode_[cIndex++] = checkFace[nI];
+                                cellToNode_[cIndex++] = checkFace.nextLabel(nI);
+                                cellToNode_[cIndex++] = fPair.second();
+                                cellToNode_[cIndex++] = cellPoint;
+
+                                mixedTypes_[cellIndex++] = cellType[0];
+                            }
+                        }
+                    }
+                }
+
                 break;
             }
         }
     }
 
+    // Condense the faceMarker
+    if (nFacePoints)
+    {
+        nFacePoints = 0;
+
+        forAll(faceMarker, faceI)
+        {
+            const labelPair& fPair = faceMarker[faceI];
+
+            if (fPair.first() > -1)
+            {
+                decompFaceCentres_[nFacePoints++] = fPair;
+            }
+        }
+    }
+
+    faceMarker.clear();
+
     // Fix patch information, but blank out first
-    forAll(refPoints_, pointI)
+    forAll(fixFlags_, pointI)
     {
         fixFlags_[pointI] = 0;
     }
@@ -1330,9 +1634,30 @@ void mesquiteMotionSolver::initArrays()
         }
     }
 
-    // Optionally fix additional zone points
-    const dictionary& optionsDict = subDict("mesquiteOptions");
+    // Fix points on decomposed boundary faces
+    forAll(decompFaceCentres_, indexI)
+    {
+        label fIndex = decompFaceCentres_[indexI].first();
+        label pIndex = decompFaceCentres_[indexI].second();
 
+        label patchI = boundary.whichPatch(fIndex);
+
+        if (patchI < 0)
+        {
+            continue;
+        }
+
+        // Leave processor boundaries out.
+        if (boundary[patchI].type() == "processor")
+        {
+            continue;
+        }
+
+        // Point is on physical boundary patch
+        fixFlags_[pIndex] = 1;
+    }
+
+    // Optionally fix additional zone points
     if (optionsDict.found("fixPointsZone"))
     {
         wordList fixZones = optionsDict.subDict("fixPointsZone").toc();
@@ -1624,6 +1949,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
 
     forAll(pIDs_, patchI)
     {
+        const label pOffset = offsets_[patchI];
         const pointField& points = boundary[pIDs_[patchI]].localPoints();
 
         forAll(boundary, patchJ)
@@ -1648,8 +1974,8 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
             }
 
             // Fetch references
-            Map<label>& aspMap = sendSurfPointMap_[pI];
-            Map<label>& anbMap = recvSurfPointMap_[pI];
+            Map<label>& sspMap = sendSurfPointMap_[pI];
+            Map<label>& rspMap = recvSurfPointMap_[pI];
             DynamicList<point>& asPoints = auxSurfPoints[pI];
 
             // Fetch mesh points for this patch
@@ -1666,7 +1992,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                 }
 
                 // Locate index in field
-                label fieldIndex = local + offsets_[patchI];
+                label fieldIndex = local + pOffset;
 
                 // Fix boundary condition for this point.
                 bdy_[fieldIndex] = vector::one;
@@ -1678,10 +2004,10 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                 }
 
                 // Add an entry if it wasn't done before
-                if (!aspMap.found(fieldIndex))
+                if (!sspMap.found(fieldIndex))
                 {
-                    aspMap.insert(fieldIndex, asPoints.size());
-                    anbMap.insert(fieldIndex, asPoints.size());
+                    sspMap.insert(fieldIndex, asPoints.size());
+                    rspMap.insert(fieldIndex, asPoints.size());
 
                     // Insert corresponding point
                     asPoints.append(points[local]);
@@ -1694,8 +2020,8 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
         forAll(globalProcPoints_, pI)
         {
             // Fetch references
-            Map<label>& aspMap = sendSurfPointMap_[pI];
-            Map<label>& anbMap = recvSurfPointMap_[pI];
+            Map<label>& sspMap = sendSurfPointMap_[pI];
+            Map<label>& rspMap = recvSurfPointMap_[pI];
             DynamicList<point>& asPoints = auxSurfPoints[pI];
 
             const List<labelPair>& pLabels = globalProcPoints_[pI];
@@ -1717,7 +2043,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                 }
 
                 // Locate index in field
-                label fieldIndex = local + offsets_[patchI];
+                label fieldIndex = local + pOffset;
 
                 // Fix boundary condition for this point.
                 bdy_[fieldIndex] = vector::one;
@@ -1729,7 +2055,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                 }
 
                 // Add an entry if it wasn't done before
-                if (!aspMap.found(fieldIndex))
+                if (!sspMap.found(fieldIndex))
                 {
                     if (debug)
                     {
@@ -1738,8 +2064,8 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                             << endl;
                     }
 
-                    aspMap.insert(fieldIndex, asPoints.size());
-                    anbMap.insert(fieldIndex, asPoints.size());
+                    sspMap.insert(fieldIndex, asPoints.size());
+                    rspMap.insert(fieldIndex, asPoints.size());
 
                     // Insert corresponding point
                     asPoints.append(points[local]);
@@ -1751,7 +2077,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
     // Check to ensure that field sizes match
     labelList nProcSize(procIndices_.size(), -1);
 
-    forAll(sendSurfPointMap_, pI)
+    forAll(procIndices_, pI)
     {
         // Send size to neighbour
         parWrite(procIndices_[pI], sendSurfPointMap_[pI].size());
@@ -1784,6 +2110,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
     // Prepare edgeMarkers
     forAll(pIDs_, patchI)
     {
+        const label pOffset = offsets_[patchI];
         const edgeList& edges = boundary[pIDs_[patchI]].edges();
         const labelList& meshEdges = boundary[pIDs_[patchI]].meshEdges();
 
@@ -1796,8 +2123,8 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
         {
             // If both points on this edge are marked,
             // this edge needs to be left out.
-            label i0 = edges[i][0] + offsets_[patchI];
-            label i1 = edges[i][1] + offsets_[patchI];
+            label i0 = edges[i][0] + pOffset;
+            label i1 = edges[i][1] + pOffset;
 
             bool p0 = (pointMarker_[i0] < 0.5);
             bool p1 = (pointMarker_[i1] < 0.5);
@@ -1838,21 +2165,28 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
         }
     }
 
+    // Configure a magnitude for distance matching
+    const boundBox& box = mesh().bounds();
+
+    const vector outsideBoxMax = box.max() + vector::one;
+
     // Send and receive points for geometric match
-    forAll(sendSurfPointMap_, pI)
+    forAll(procIndices_, pI)
     {
         label proc = procIndices_[pI];
 
         // Set size to max, in case of mismatch
         label maxSize = Foam::max(sendSurfPointMap_[pI].size(), nProcSize[pI]);
 
-        // Size-up send / recv fields
-        sendSurfFields_[pI].setSize(maxSize, vector::zero);
-        recvSurfFields_[pI].setSize(maxSize, vector::zero);
-
         // Fetch references
+        const DynamicList<point>& bufPoints = auxSurfPoints[pI];
+
+        vectorField& sendField = sendSurfFields_[pI];
         vectorField& recvField = recvSurfFields_[pI];
-        DynamicList<point>& bufPoints = auxSurfPoints[pI];
+
+        // Size-up send / recv fields
+        sendField.setSize(maxSize, vector::zero);
+        recvField.setSize(maxSize, vector::zero);
 
         // Send and receive points
         if (recvField.size())
@@ -1861,18 +2195,32 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
             parRead(proc, recvField);
         }
 
-        if (bufPoints.size())
+        if (sendField.size())
         {
+            // Copy auxiliary points.
+            // If there is a mismatch, send invalid values
+            // so that geometric matches don't result in
+            // false positives. This can occur in situations
+            // where points on a neighbouring processor lie
+            // on a slip patch, but this processor touches
+            // the patch only via points or edges.
+            forAll(bufPoints, pointI)
+            {
+                sendField[pointI] = bufPoints[pointI];
+            }
+
+            for (label i = bufPoints.size(); i < sendField.size(); ++i)
+            {
+                sendField[i] = outsideBoxMax;
+            }
+
             // Send points to neighbour
-            parWrite(proc, bufPoints);
+            parWrite(proc, sendField);
         }
     }
 
-    // Configure a magnitude for distance matching
-    const boundBox& box = mesh().bounds();
-
     // Fetch relative tolerance
-    scalar relTol = debug::tolerances("processorMatchTol", 1e-4);
+    scalar relTol = 1e-4;
 
     // Compute tolerance
     scalar tol = relTol * box.mag();
@@ -1884,7 +2232,7 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
     // Set up a reversePointMap for mismatches
     labelListList reversePointMap(procIndices_.size());
 
-    forAll(sendSurfPointMap_, pI)
+    forAll(procIndices_, pI)
     {
         // Fetch references
         vectorField& recvField = recvSurfFields_[pI];
@@ -1902,13 +2250,18 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
             pointMap
         );
 
+        // Alias for convenience
+        labelList& reverseMap = reversePointMap[pI];
+
         // Size-up the reverse-map
-        reversePointMap[pI].setSize(nProcSize[pI], -1);
+        reverseMap.setSize(nProcSize[pI], -1);
 
         // Fill reversePointMap
         forAll(pointMap, pointI)
         {
-            if (pointMap[pointI] < 0)
+            label mapIndex = pointMap[pointI];
+
+            if (mapIndex < 0)
             {
                 if (debug)
                 {
@@ -1921,16 +2274,16 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
                 continue;
             }
 
-            reversePointMap[pI][pointMap[pointI]] = pointI;
+            reverseMap[mapIndex] = pointI;
         }
 
         // Check reversePointMap for unfilled points
-        forAll(reversePointMap[pI], pointI)
+        forAll(reverseMap, pointI)
         {
             // Compute tolSqr for matching
             scalar tolSqr = sqr(tol);
 
-            if (reversePointMap[pI][pointI] == -1)
+            if (reverseMap[pointI] == -1)
             {
                 // Search my points for the unmatched point
                 const vector& uPoint = recvField[pointI];
@@ -1962,13 +2315,14 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
         }
 
         // Renumber to shuffled indices
-        Map<label>& anbMap = recvSurfPointMap_[pI];
+        Map<label>& rspMap = recvSurfPointMap_[pI];
 
-        forAllIter(Map<label>, anbMap, pIter)
+        forAllIter(Map<label>, rspMap, pIter)
         {
             // Skip mismatches
             if (pointMap[pIter()] < 0)
             {
+                rspMap.erase(pIter);
                 continue;
             }
 
@@ -1976,6 +2330,13 @@ void mesquiteMotionSolver::initParallelSurfaceSmoothing()
         }
     }
 
+    // Reset buffers
+    forAll(procIndices_, pI)
+    {
+        sendSurfFields_[pI] = vector::zero;
+        recvSurfFields_[pI] = vector::zero;
+    }
+
     // Fix boundary conditions
     transferBuffers(bdyMarker);
 
@@ -2044,22 +2405,45 @@ void mesquiteMotionSolver::initMesquiteParallelArrays()
     List<labelList> neiTypes(procIndices_.size());
     List<DynamicList<label> > myTypes(procIndices_.size());
 
+    const dictionary& optionsDict = subDict("mesquiteOptions");
+
     // Construct shape recognizers
     FixedList<autoPtr<cellMatcher>, 4> matcher;
     FixedList<Mesquite::EntityTopology, 4> cellType;
 
     // Set types
-    matcher[0].set(new hexMatcher());
-    cellType[0] = Mesquite::HEXAHEDRON;
+    bool standardTypes = false;
 
-    matcher[1].set(new tetMatcher());
-    cellType[1] = Mesquite::TETRAHEDRON;
+    if (optionsDict.found("standardCellTypes"))
+    {
+        standardTypes = readBool(optionsDict.lookup("standardCellTypes"));
+    }
 
-    matcher[2].set(new pyrMatcher());
-    cellType[2] = Mesquite::PYRAMID;
+    if (standardTypes)
+    {
+        matcher[0].set(new tetMatcher());
+        cellType[0] = Mesquite::TETRAHEDRON;
 
-    matcher[3].set(new prismMatcher());
-    cellType[3] = Mesquite::PRISM;
+        matcher[1].set(new hexMatcher());
+        cellType[1] = Mesquite::HEXAHEDRON;
+
+        matcher[2].set(new pyrMatcher());
+        cellType[2] = Mesquite::PYRAMID;
+
+        matcher[3].set(new prismMatcher());
+        cellType[3] = Mesquite::PRISM;
+    }
+    else
+    {
+        // No standard types.
+        // Default to tetrahedra, and decompose the rest.
+        matcher[0].set(new tetMatcher());
+        cellType[0] = Mesquite::TETRAHEDRON;
+
+        matcher[1].set(NULL);
+        matcher[2].set(NULL);
+        matcher[3].set(NULL);
+    }
 
     const cellList& cells = mesh().cells();
     const faceList& faces = mesh().faces();
@@ -2152,7 +2536,11 @@ void mesquiteMotionSolver::initMesquiteParallelArrays()
 
                 forAll(matcher, indexI)
                 {
-                    if (matcher[indexI]->isA(mesh(), pCells[cellI]))
+                    if
+                    (
+                        matcher[indexI].valid() &&
+                        matcher[indexI]->isA(mesh(), pCells[cellI])
+                    )
                     {
                         // Match shape
                         matcher[indexI]->matchShape
@@ -2196,23 +2584,23 @@ void mesquiteMotionSolver::initMesquiteParallelArrays()
                     }
                 }
 
+                // Add to list
+                addedCells.insert(pCells[cellI], nProcCells++);
+
                 if (!foundMatch)
                 {
                     Pout<< " Unknown type for cell: " << pCells[cellI]
                         << " :: " << cells[pCells[cellI]]
                         << abort(FatalError);
                 }
-
-                // Add to list
-                addedCells.insert(pCells[cellI], nProcCells++);
             }
         }
 
         // Estimate size for cellToNode
         label nCellToNode =
         (
-            (8 * nTypes[0])
-          + (4 * nTypes[1])
+            (4 * nTypes[0])
+          + (8 * nTypes[1])
           + (5 * nTypes[2])
           + (6 * nTypes[3])
         );
@@ -2305,9 +2693,9 @@ void mesquiteMotionSolver::initMesquiteParallelArrays()
         nExtraCellToNode += nAuxCellToNode[pI];
     }
 
-    List<double> vtxCoordsNew(3 * (nPoints_ + nExtraPoints));
+    List<double> vtxCoordsNew(3 * (nPoints_ + nDecompPoints_ + nExtraPoints));
     List<unsigned long> cellToNodeNew(nCellToNode + nExtraCellToNode);
-    List<int> fixFlagsNew(nPoints_ + nExtraPoints);
+    List<int> fixFlagsNew(nPoints_ + nDecompPoints_ + nExtraPoints);
     List<Mesquite::EntityTopology> mixedTypesNew(nCells_ + nExtraCells);
 
     // Copy existing arrays
@@ -2384,7 +2772,7 @@ void mesquiteMotionSolver::initMesquiteParallelArrays()
     }
 
     label expectedCells = (nCellToNode + nExtraCellToNode);
-    label expectedPoints = (nPoints_ + nExtraPoints);
+    label expectedPoints = (nPoints_ + nDecompPoints_ + nExtraPoints);
 
     if ( (cIndex != expectedCells) || (pIndex != expectedPoints) )
     {
@@ -2469,9 +2857,265 @@ void mesquiteMotionSolver::initParallelConnectivity()
 }
 
 
+// Compute centroids based on up-to-date point positions
+void mesquiteMotionSolver::computeCentroids
+(
+    const pointField& p,
+    pointField& fCtrs,
+    pointField& cCtrs
+)
+{
+    label nInvTets = 0;
+    scalarField cVols(mesh().nCells(), 0.0);
+
+    // Size the lists
+    fCtrs.setSize(mesh().nFaces(), vector::zero);
+    cCtrs.setSize(mesh().nCells(), vector::zero);
+
+    const faceList& fs = mesh().faces();
+
+    forAll(fs, faceI)
+    {
+        const face& f = fs[faceI];
+
+        label nPoints = f.size();
+
+        if (nPoints == 3)
+        {
+            fCtrs[faceI] = (1.0/3.0)*(p[f[0]] + p[f[1]] + p[f[2]]);
+        }
+        else
+        {
+            scalar sumA = 0.0;
+            vector sumAc = vector::zero;
+
+            point fCentre = p[f[0]];
+
+            for (label pi = 1; pi < nPoints; pi++)
+            {
+                fCentre += p[f[pi]];
+            }
+
+            fCentre /= nPoints;
+
+            for (label pi = 0; pi < nPoints; pi++)
+            {
+                const point& nextPoint = p[f[(pi + 1) % nPoints]];
+
+                vector c = p[f[pi]] + nextPoint + fCentre;
+                vector n = (nextPoint - p[f[pi]])^(fCentre - p[f[pi]]);
+                scalar a = mag(n);
+
+                sumA += a;
+                sumAc += a*c;
+            }
+
+            fCtrs[faceI] = (1.0/3.0)*sumAc/(sumA + VSMALL);
+        }
+    }
+
+    const labelList& own = mesh().faceOwner();
+    const labelList& nei = mesh().faceNeighbour();
+
+    labelField nCellFaces(mesh().nCells(), 0);
+    vectorField cEst(mesh().nCells(), vector::zero);
+
+    forAll (own, faceI)
+    {
+        cEst[own[faceI]] += fCtrs[faceI];
+        nCellFaces[own[faceI]] += 1;
+    }
+
+    forAll (nei, faceI)
+    {
+        cEst[nei[faceI]] += fCtrs[faceI];
+        nCellFaces[nei[faceI]] += 1;
+    }
+
+    forAll(cCtrs, cellI)
+    {
+        cEst[cellI] /= nCellFaces[cellI];
+    }
+
+    scalar tetVol;
+
+    forAll(own, faceI)
+    {
+        const face& f = fs[faceI];
+
+        if (f.size() == 3)
+        {
+            tetPointRef tpr(p[f[2]], p[f[1]], p[f[0]], cEst[own[faceI]]);
+
+            tetVol = tpr.mag();
+
+            if (tetVol < 0.0)
+            {
+                nInvTets++;
+
+                if (debug)
+                {
+                    Info<< "Warning: Inverted tetrahedron:" << nl
+                        << " tetVol: " << tetVol << nl
+                        << " tet: " << tpr << nl
+                        << " Face: " << f << endl;
+                }
+            }
+
+            // Accumulate volume-weighted tet centre
+            cCtrs[own[faceI]] += tetVol*tpr.centre();
+
+            // Accumulate tet volume
+            cVols[own[faceI]] += tetVol;
+        }
+        else
+        {
+            forAll(f, pI)
+            {
+                tetPointRef tpr
+                (
+                    p[f[pI]],
+                    p[f.prevLabel(pI)],
+                    fCtrs[faceI],
+                    cEst[own[faceI]]
+                );
+
+                tetVol = tpr.mag();
+
+                if (tetVol < 0.0)
+                {
+                    nInvTets++;
+
+                    if (debug)
+                    {
+                        Info<< "Warning: Inverted tetrahedron:" << nl
+                            << " tetVol: " << tetVol << nl
+                            << " tet: " << tpr << nl
+                            << " Face: " << f << endl;
+                    }
+                }
+
+                // Accumulate volume-weighted tet centre
+                cCtrs[own[faceI]] += tetVol*tpr.centre();
+
+                // Accumulate tet volume
+                cVols[own[faceI]] += tetVol;
+            }
+        }
+    }
+
+    forAll(nei, faceI)
+    {
+        const face& f = fs[faceI];
+
+        if (f.size() == 3)
+        {
+            tetPointRef tpr(p[f[0]], p[f[1]], p[f[2]], cEst[nei[faceI]]);
+
+            tetVol = tpr.mag();
+
+            if (tetVol < 0.0)
+            {
+                nInvTets++;
+
+                if (debug)
+                {
+                    Info<< "Warning: Inverted tetrahedron:" << nl
+                        << " tetVol: " << tetVol << nl
+                        << " tet: " << tpr << nl
+                        << " Face: " << f << endl;
+                }
+            }
+
+            // Accumulate volume-weighted tet centre
+            cCtrs[nei[faceI]] += tetVol*tpr.centre();
+
+            // Accumulate tet volume
+            cVols[nei[faceI]] += tetVol;
+        }
+        else
+        {
+            forAll(f, pI)
+            {
+                tetPointRef tpr
+                (
+                    p[f[pI]],
+                    p[f.nextLabel(pI)],
+                    fCtrs[faceI],
+                    cEst[nei[faceI]]
+                );
+
+                tetVol = tpr.mag();
+
+                if (tetVol < 0.0)
+                {
+                    nInvTets++;
+
+                    if (debug)
+                    {
+                        Info<< "Warning: Inverted tetrahedron:" << nl
+                            << " tetVol: " << tetVol << nl
+                            << " tet: " << tpr << nl
+                            << " Face: " << f << endl;
+                    }
+                }
+
+                // Accumulate volume-weighted tet centre
+                cCtrs[nei[faceI]] += tetVol*tpr.centre();
+
+                // Accumulate tet volume
+                cVols[nei[faceI]] += tetVol;
+            }
+        }
+    }
+
+    if (nInvTets)
+    {
+        Info<< "Warning: Inverted tetrahedralisation was found:" << nl
+            << " nInvTets: " << nInvTets << nl
+            << " Enable debug flag for more information." << endl;
+    }
+
+    cCtrs /= cVols + VSMALL;
+}
+
+
 // Copy auxiliary points to/from buffers
 void mesquiteMotionSolver::copyAuxiliaryPoints(bool firstCopy)
 {
+    if (firstCopy && nDecompPoints_)
+    {
+        // Compute up-to-date centroids
+        vectorField xF, xC;
+
+        computeCentroids(refPoints_, xF, xC);
+
+        // Copy points from decomposition
+        forAll(decompCellCentres_, indexI)
+        {
+            label cIndex = decompCellCentres_[indexI].first();
+            label pIndex = decompCellCentres_[indexI].second();
+
+            const vector& v = xC[cIndex];
+
+            vtxCoords_[(3*pIndex)+0] = v.x();
+            vtxCoords_[(3*pIndex)+1] = v.y();
+            vtxCoords_[(3*pIndex)+2] = v.z();
+        }
+
+        forAll(decompFaceCentres_, indexI)
+        {
+            label fIndex = decompFaceCentres_[indexI].first();
+            label pIndex = decompFaceCentres_[indexI].second();
+
+            const vector& v = xF[fIndex];
+
+            vtxCoords_[(3*pIndex)+0] = v.x();
+            vtxCoords_[(3*pIndex)+1] = v.y();
+            vtxCoords_[(3*pIndex)+2] = v.z();
+        }
+    }
+
     if (!Pstream::parRun())
     {
         return;
@@ -2654,14 +3298,15 @@ void mesquiteMotionSolver::A
     // Gradient (n2e)
     forAll(pIDs_, patchI)
     {
+        const label pOffset = offsets_[patchI];
         const edgeList& edges = boundary[pIDs_[patchI]].edges();
 
         forAll(edges, edgeI)
         {
             gradEdge_[patchI][edgeI] =
             (
-                p[edges[edgeI][1] + offsets_[patchI]]
-              - p[edges[edgeI][0] + offsets_[patchI]]
+                p[edges[edgeI][1] + pOffset]
+              - p[edges[edgeI][0] + pOffset]
             );
         }
     }
@@ -2669,14 +3314,18 @@ void mesquiteMotionSolver::A
     // Divergence (e2n)
     forAll(pIDs_, patchI)
     {
+        const label pOffset = offsets_[patchI];
         const edgeList& edges = boundary[pIDs_[patchI]].edges();
 
         forAll(edges, edgeI)
         {
             gradEdge_[patchI][edgeI] *= edgeMarker_[patchI][edgeI];
 
-            w[edges[edgeI][0] + offsets_[patchI]] += gradEdge_[patchI][edgeI];
-            w[edges[edgeI][1] + offsets_[patchI]] -= gradEdge_[patchI][edgeI];
+            // Account for edge constant
+            gradEdge_[patchI][edgeI] *= edgeConstant_[patchI][edgeI];
+
+            w[edges[edgeI][0] + pOffset] += gradEdge_[patchI][edgeI];
+            w[edges[edgeI][1] + pOffset] -= gradEdge_[patchI][edgeI];
         }
     }
 
@@ -2691,7 +3340,8 @@ void mesquiteMotionSolver::A
 // Transfer buffers for surface point fields
 void mesquiteMotionSolver::transferBuffers
 (
-    vectorField& field
+    vectorField& field,
+    bool fix
 )
 {
     if (!Pstream::parRun())
@@ -2738,10 +3388,21 @@ void mesquiteMotionSolver::transferBuffers
 
         if (recvField.size())
         {
-            // Correct field values
-            forAllConstIter(Map<label>, pointMap, pIter)
+            if (fix)
             {
-                field[pIter.key()] += recvField[pIter()];
+                // Fix field values
+                forAllConstIter(Map<label>, pointMap, pIter)
+                {
+                    field[pIter.key()] = recvField[pIter()];
+                }
+            }
+            else
+            {
+                // Correct field values
+                forAllConstIter(Map<label>, pointMap, pIter)
+                {
+                    field[pIter.key()] += recvField[pIter()];
+                }
             }
         }
     }
@@ -2756,14 +3417,16 @@ void mesquiteMotionSolver::applyBCs
 {
     forAll(pIDs_, patchI)
     {
+        const label pOffset = offsets_[patchI];
+
         // Apply slip conditions for internal nodes
         forAll(pNormals_[patchI], pointI)
         {
             const vector& n = pNormals_[patchI][pointI];
 
-            field[pointI + offsets_[patchI]] -=
+            field[pointI + pOffset] -=
             (
-                (field[pointI + offsets_[patchI]] & n)*n
+                (field[pointI + pOffset] & n)*n
             );
         }
     }
@@ -2781,8 +3444,9 @@ void mesquiteMotionSolver::applyBCs
     {
         if (Foam::min(bdy_) > vector(0.5,0.5,0.5))
         {
-            Random randomizer(1);
-            label nFix = (field.size()*5)/100;
+            Random randomizer(std::time(NULL));
+
+            label nFix = 0; //(field.size()*5)/100;
 
             for(label i = 0; i < nFix; i++)
             {
@@ -2839,8 +3503,8 @@ scalar mesquiteMotionSolver::normFactor
 
     A(vectorField(x.size(), xRef), tmpField);
 
-    vectorField nFw = (w - tmpField);
-    vectorField nFb = (b - tmpField);
+    tmp<vectorField> nFw = (w - tmpField);
+    tmp<vectorField> nFb = (b - tmpField);
 
     if (debug)
     {
@@ -3025,58 +3689,101 @@ void mesquiteMotionSolver::applyFixedValuePatches()
             pField().updateCoeffs();
         }
 
-        if (Pstream::parRun() && !twoDMesh_)
+        if (Pstream::parRun())
         {
-            label nDomainPoints = refPoints_.size();
+            vector smallVec(VSMALL, VSMALL, VSMALL);
 
-            forAll(procIndices_, pI)
+            if (twoDMesh_)
             {
-                label proc = procIndices_[pI];
+                // Size up the buffer
+                vectorField parDisp(pointMarker_.size(), vector::zero);
 
-                const Map<label>& pointMap = sendPointMap_[pI];
-
-                // Fetch reference to send / recv point buffers
-                vectorField& psField = sendPointBuffer_[pI];
-                vectorField& prField = recvPointBuffer_[pI];
-
-                // Fill the send buffer
-                forAllConstIter(Map<label>, pointMap, pIter)
+                forAll(pIDs_, patchI)
                 {
-                    if (pIter.key() < nDomainPoints)
+                    const label pID = pIDs_[patchI];
+                    const label pOffset = offsets_[patchI];
+                    const labelList& meshPts = boundary[pID].meshPoints();
+
+                    forAll(meshPts, pointI)
                     {
-                        psField[pIter()] = dPointField[pIter.key()];
+                        const label gIndex = meshPts[pointI];
+                        parDisp[pOffset + pointI] = dPointField[gIndex];
                     }
                 }
 
-                // Send to neighbour
-                parWrite(proc, psField);
+                // Transfer buffers across processors
+                transferBuffers(parDisp, true);
 
-                // Receive from neighbour
-                parRead(proc, prField);
-            }
-
-            // Wait for all transfers to complete.
-            OPstream::waitRequests();
-            IPstream::waitRequests();
-
-            vector smallVec(VSMALL, VSMALL, VSMALL);
-
-            forAll(procIndices_, pI)
-            {
-                const Map<label>& pointMap = recvPointMap_[pI];
-
-                // Fetch reference to recv buffer
-                const vectorField& prField = recvPointBuffer_[pI];
-
-                forAllConstIter(Map<label>, pointMap, pIter)
+                forAll(pIDs_, patchI)
                 {
-                    // Only update points in this domain
-                    if (pIter() < nDomainPoints)
+                    const label pID = pIDs_[patchI];
+                    const label pOffset = offsets_[patchI];
+                    const labelList& meshPts = boundary[pID].meshPoints();
+
+                    forAll(meshPts, pointI)
                     {
+                        const label gIndex = meshPts[pointI];
+                        const vector& disp = parDisp[pOffset + pointI];
+
                         // Only update for non-zero displacement
-                        if (cmptMag(dPointField[pIter()]) < smallVec)
+                        if (cmptMag(dPointField[gIndex]) < smallVec)
                         {
-                            dPointField[pIter()] = prField[pIter.key()];
+                            dPointField[gIndex] = disp;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                label nDomainPoints = refPoints_.size();
+
+                forAll(procIndices_, pI)
+                {
+                    label proc = procIndices_[pI];
+
+                    const Map<label>& pointMap = sendPointMap_[pI];
+
+                    // Fetch reference to send / recv point buffers
+                    vectorField& psField = sendPointBuffer_[pI];
+                    vectorField& prField = recvPointBuffer_[pI];
+
+                    // Fill the send buffer
+                    forAllConstIter(Map<label>, pointMap, pIter)
+                    {
+                        if (pIter.key() < nDomainPoints)
+                        {
+                            psField[pIter()] = dPointField[pIter.key()];
+                        }
+                    }
+
+                    // Send to neighbour
+                    parWrite(proc, psField);
+
+                    // Receive from neighbour
+                    parRead(proc, prField);
+                }
+
+                // Wait for all transfers to complete.
+                OPstream::waitRequests();
+                IPstream::waitRequests();
+
+                forAll(procIndices_, pI)
+                {
+                    const Map<label>& pointMap = recvPointMap_[pI];
+
+                    // Fetch reference to recv buffer
+                    const vectorField& prField = recvPointBuffer_[pI];
+
+                    forAllConstIter(Map<label>, pointMap, pIter)
+                    {
+                        // Only update points in this domain
+                        if (pIter() < nDomainPoints)
+                        {
+                            // Only update for non-zero displacement
+                            if (cmptMag(dPointField[pIter()]) < smallVec)
+                            {
+                                dPointField[pIter()] = prField[pIter.key()];
+                            }
                         }
                     }
                 }
@@ -3116,14 +3823,18 @@ void mesquiteMotionSolver::smoothSurfaces()
         // Copy existing point-positions
         forAll(pIDs_, patchI)
         {
+            const label pOffset = offsets_[patchI];
             const labelList& meshPts = boundary[pIDs_[patchI]].meshPoints();
 
             forAll(meshPts,pointI)
             {
-                xV_[pointI + offsets_[patchI]] = refPoints_[meshPts[pointI]];
+                xV_[pointI + pOffset] = refPoints_[meshPts[pointI]];
             }
         }
 
+        // Prepare edge constants
+        prepareEdgeConstants(xV_);
+
         Info<< "Solving for point motion: ";
 
         label iters = CG(bV_, pV_, rV_, wV_, xV_);
@@ -3133,13 +3844,14 @@ void mesquiteMotionSolver::smoothSurfaces()
         // Update refPoints (with relaxation if necessary)
         forAll(pIDs_, patchI)
         {
+            const label pOffset = offsets_[patchI];
             const labelList& meshPts = boundary[pIDs_[patchI]].meshPoints();
 
             forAll(meshPts,pointI)
             {
                 refPoints_[meshPts[pointI]] =
                 (
-                    (relax_ * xV_[pointI + offsets_[patchI]])
+                    (relax_ * xV_[pointI + pOffset])
                   + ((1.0 - relax_) * origPoints_[meshPts[pointI]])
                 );
             }
@@ -3166,11 +3878,12 @@ void mesquiteMotionSolver::smoothSurfaces()
         // Fill buffers with current points, and transfer
         forAll(pIDs_, patchI)
         {
+            const label pOffset = offsets_[patchI];
             const labelList& meshPts = boundary[pIDs_[patchI]].meshPoints();
 
             forAll(meshPts,pointI)
             {
-                xV_[pointI + offsets_[patchI]] = refPoints_[meshPts[pointI]];
+                xV_[pointI + pOffset] = refPoints_[meshPts[pointI]];
             }
         }
 
@@ -3385,7 +4098,7 @@ void mesquiteMotionSolver::correctInvalidCells()
     // Fetch the sub-dictionary
     const dictionary& optionsDict = subDict("mesquiteOptions");
 
-    bool checkTetValidity = false;
+    bool checkTetValidity = true;
 
     if (optionsDict.found("checkTetValidity"))
     {
@@ -3708,6 +4421,9 @@ void mesquiteMotionSolver::enforceCylindricalConstraints()
 
             axisVector /= mag(axisVector) + VSMALL;
 
+            scalar maxViol = 0.0;
+            label nViolations = 0;
+
             forAll(meshPts, pointI)
             {
                 point& x = refPoints_[meshPts[pointI]];
@@ -3726,15 +4442,20 @@ void mesquiteMotionSolver::enforceCylindricalConstraints()
 
                     if (viol > SMALL)
                     {
-                        WarningIn
-                        (
-                            "void mesquiteMotionSolver::"
-                            "enforceCylindricalConstraints()"
-                        )
-                            << " Constraint violation: " << viol << endl;
+                        ++nViolations;
+
+                        maxViol = (viol > maxViol) ? viol : maxViol;
                     }
                 }
             }
+
+            if (debug)
+            {
+                Pout<< " Patch: " << cstrPatches[wordI]
+                    << " No. of violations: " << nViolations
+                    << " Max constraint violation: " << maxViol
+                    << endl;
+            }
         }
     }
 }
@@ -3862,6 +4583,50 @@ void mesquiteMotionSolver::preparePointNormals()
 }
 
 
+// Prepare non-uniform edge constants with updated point positions
+void mesquiteMotionSolver::prepareEdgeConstants
+(
+    const vectorField& p
+)
+{
+    // Fetch the sub-dictionary
+    const dictionary& optionsDict = subDict("mesquiteOptions");
+
+    // Check for sub-dictionary entry
+    if (!optionsDict.found("nonUniformEdgeConstant"))
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info<< "Preparing non-uniform edge constants" << endl;
+    }
+
+    const polyBoundaryMesh& boundary = mesh().boundaryMesh();
+
+    forAll(pIDs_, patchI)
+    {
+        const label pOffset = offsets_[patchI];
+        const edgeList& edges = boundary[pIDs_[patchI]].edges();
+
+        scalarField& k = edgeConstant_[patchI];
+
+        forAll(edges, edgeI)
+        {
+            k[edgeI] =
+            (
+                Foam::mag
+                (
+                    p[edges[edgeI][1] + pOffset]
+                  - p[edges[edgeI][0] + pOffset]
+                )
+            );
+        }
+    }
+}
+
+
 //- Return point location obtained from the current motion field
 tmp<pointField> mesquiteMotionSolver::curPoints() const
 {
@@ -3910,6 +4675,11 @@ void mesquiteMotionSolver::solve()
         enforceCylindricalConstraints();
     }
 
+    if (twoDMesh_)
+    {
+        return;
+    }
+
     // Copy refPoints prior to internal smoothing
     origPoints_ = refPoints_;
 
@@ -3931,7 +4701,7 @@ void mesquiteMotionSolver::solve()
     msqMesh
     (
         3,                         // Number of coords per vertex
-        nPoints_,                  // Number of vertices
+        nPoints_ + nDecompPoints_, // Number of vertices
         vtxCoords_.begin(),        // The vertex coordinates
         fixFlags_.begin(),         // Fixed vertex flags
         nCells_,                   // Number of elements
@@ -4057,10 +4827,15 @@ void mesquiteMotionSolver::update(const mapPolyMesh& mpm)
         pNormals_.clear();
         offsets_.clear();
         edgeMarker_.clear();
+        edgeConstant_.clear();
     }
 
     nPoints_ = Mesh_.nPoints();
-    nCells_ = Mesh_.nCells();
+    nCells_ = 0;
+    nDecompPoints_ = 0;
+
+    decompCellCentres_.clear();
+    decompFaceCentres_.clear();
 
     nAuxPoints_.clear();
     nAuxCells_.clear();
diff --git a/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.H b/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.H
index 4211a6994..91054a77c 100644
--- a/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.H
+++ b/src/dynamicMesh/meshMotion/mesquiteMotionSolver/mesquiteMotionSolver.H
@@ -49,10 +49,18 @@ SourceFiles
 // Have gcc ignore certain warnings while including mesquite headers
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 #   pragma GCC diagnostic ignored "-Wold-style-cast"
+#   pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#   pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #endif
 
 #include "Mesquite_all_headers.hpp"
 
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#   pragma GCC diagnostic warning "-Wold-style-cast"
+#   pragma GCC diagnostic warning "-Wnon-virtual-dtor"
+#   pragma GCC diagnostic warning "-Wunused-but-set-variable"
+#endif
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
@@ -88,6 +96,17 @@ class mesquiteMotionSolver
         //- Number of elements
         unsigned long nCells_;
 
+        //- Polyhedra decomposition type
+        //  1: for cell, 2: for face
+        label decompType_;
+
+        //- Number of points from poly decomposition
+        unsigned long nDecompPoints_;
+
+        //- List of decomposition centres
+        List<labelPair> decompCellCentres_;
+        List<labelPair> decompFaceCentres_;
+
         //- Number of auxiliary points
         labelList nAuxPoints_;
 
@@ -106,7 +125,7 @@ class mesquiteMotionSolver
         //- Specify max volume correction iterations
         label volCorrMaxIter_;
 
-        // Specify tolerance for the CG solver
+        //- Specify tolerance for the CG solver
         scalar tolerance_;
 
         //- Specify multiple mesh-motion sweeps
@@ -159,6 +178,7 @@ class mesquiteMotionSolver
         List<vectorField> gradEdge_;
         List<vectorField> localPts_;
         List<scalarField> edgeMarker_;
+        List<scalarField> edgeConstant_;
 
         //- Data for the auxiliary entities
         labelList procIndices_;
@@ -219,7 +239,7 @@ class mesquiteMotionSolver
         scalar cmptSumMag(const vectorField& field);
 
         // Transfer buffers for surface point fields
-        void transferBuffers(vectorField &field);
+        void transferBuffers(vectorField &field, bool fix = false);
 
         // Apply boundary conditions
         void applyBCs(vectorField &field);
@@ -253,6 +273,14 @@ class mesquiteMotionSolver
         // Prepare mesquite connectivity for parallel runs
         void initMesquiteParallelArrays();
 
+        // Compute centroids based on up-to-date point positions
+        void computeCentroids
+        (
+            const pointField& points,
+            pointField& faceCentres,
+            pointField& cellCentres
+        );
+
         // Copy auxiliary points to/from buffers
         void copyAuxiliaryPoints(bool firstCopy);
 
@@ -286,6 +314,9 @@ class mesquiteMotionSolver
         // Prepare point-normals with updated point positions
         void preparePointNormals();
 
+        // Prepare non-uniform edge constants with updated point positions
+        void prepareEdgeConstants(const vectorField& p);
+
         // Utility method to check validity of cells connected to a point.
         bool checkValidity
         (
diff --git a/tutorials/mesh/moveDynamicMesh/circCylinder3d/constant/dynamicMeshDict b/tutorials/mesh/moveDynamicMesh/circCylinder3d/constant/dynamicMeshDict
index 494d8ca09..52c222cb5 100644
--- a/tutorials/mesh/moveDynamicMesh/circCylinder3d/constant/dynamicMeshDict
+++ b/tutorials/mesh/moveDynamicMesh/circCylinder3d/constant/dynamicMeshDict
@@ -15,6 +15,9 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+//- Specify dynamicFvMesh library
+dynamicFvMeshLibs       ("libdynamicTopoFvMesh.so");
+
 //- Select the type of dynamicFvMesh
 dynamicFvMesh           dynamicTopoFvMesh;