diff --git a/src/OpenFOAM/containers/Lists/Stack/Stack.H b/src/OpenFOAM/containers/Lists/Stack/Stack.H
new file mode 100644
index 000000000..2f0ba58dc
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/Stack/Stack.H
@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Stack
+
+Description
+    Thread-safe stack implementation using an internal DynamicList
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    StackI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Stack_H
+#define Stack_H
+
+#include "label.H"
+#include "DynamicList.H"
+#include "multiThreader.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class Stack Declaration
+\*---------------------------------------------------------------------------*/
+
+class Stack
+{
+    // Private data
+
+        //- Internal list
+        DynamicList<label> stack_;
+
+        //- Mutex for multi-threading
+        Mutex stackMutex_;
+
+public:
+
+    // Constructor
+    Stack(){}
+
+    // Member functions for access to the stack
+
+        //- Push items on to the stack
+        inline void push(const label index);
+
+        //- Insert item onto stack
+        inline void insert(const label index);
+
+        //- Pop an item off the stack
+        inline label pop();
+
+        //- Remove a specific index off the stack
+        inline void remove(const label index);
+
+        //- Return if a stack is empty or not
+        inline bool empty();
+
+        //- Return the size of the stack
+        inline label size();
+
+        //- Clear out the stack
+        inline void clear();
+
+        //- Print out the stack
+        inline void print();
+
+        //- Access the stack as a list
+        inline label operator[](const label index);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "StackI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/Lists/Stack/StackI.H b/src/OpenFOAM/containers/Lists/Stack/StackI.H
new file mode 100644
index 000000000..cf20af313
--- /dev/null
+++ b/src/OpenFOAM/containers/Lists/Stack/StackI.H
@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Stack
+
+Description
+    Member functions of the Stack class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Push items on to the stack
+inline void Stack::push(const label index)
+{
+    stackMutex_.lock();
+
+    if (findIndex(stack_, index) == -1)
+    {
+        stack_.append(index);
+    }
+
+    stackMutex_.unlock();
+}
+
+
+//- Insert item onto stack (no checking)
+inline void Stack::insert(const label index)
+{
+    stack_.append(index);
+}
+
+
+// Pop an item off the stack
+inline label Stack::pop()
+{
+    stackMutex_.lock();
+
+    const label index = stack_.remove();
+
+    stackMutex_.unlock();
+
+    return index;
+}
+
+
+// Remove a specific item off the stack
+inline void Stack::remove(const label index)
+{
+    stackMutex_.lock();
+
+    label loc = findIndex(stack_, index);
+
+    if (loc != -1)
+    {
+        // Create a new list
+        labelList newList(stack_.size() - 1);
+
+        label n = 0;
+
+        // Copy items upto location
+        for(label i = 0; i < loc; i++)
+        {
+            newList[n++] = stack_[i];
+        }
+
+        // Copy items from location
+        for(label i = (loc + 1); i < stack_.size(); i++)
+        {
+            newList[n++] = stack_[i];
+        }
+
+        // Overwrite
+        stack_ = newList;
+    }
+
+    stackMutex_.unlock();
+}
+
+
+// Return if the stack is empty or not
+inline bool Stack::empty()
+{
+    return (stack_.size() == 0);
+}
+
+
+//- Return the size of the stack
+inline label Stack::size()
+{
+    return stack_.size();
+}
+
+
+//- Clear out the stack
+inline void Stack::clear()
+{
+    stackMutex_.lock();
+
+    stack_.clear();
+
+    stackMutex_.unlock();
+}
+
+
+//- Print out the stack
+inline void Stack::print()
+{
+    Info << stack_ << endl;
+}
+
+
+//- Access the stack as a list
+inline label Stack::operator[]
+(
+    const label index
+)
+{
+    return stack_[index];
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/Make/files b/src/dynamicMesh/dynamicFvMesh/Make/files
index acff048c6..94e12864e 100644
--- a/src/dynamicMesh/dynamicFvMesh/Make/files
+++ b/src/dynamicMesh/dynamicFvMesh/Make/files
@@ -23,4 +23,22 @@ turboFvMesh/turboFvMesh.C
 tetMetrics/tetMetric.C
 tetMetrics/tetMetrics.C
 
+lengthScaleEstimator/lengthScaleEstimator.C
+
+eMesh = dynamicTopoFvMesh/eMesh
+$(eMesh)/eMesh.C
+$(eMesh)/eMeshDemandDrivenData.C
+$(eMesh)/eBoundaryMesh/eBoundaryMesh.C
+ePatches = $(eMesh)/ePatches
+$(ePatches)/ePatch/ePatch.C
+$(ePatches)/ePatch/newEPatch.C
+dynamicTopoFvMesh/meshOps.C
+dynamicTopoFvMesh/dynamicTopoFvMesh.C
+dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
+dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
+dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
+dynamicTopoFvMesh/edgeSwap.C
+dynamicTopoFvMesh/edgeBisect.C
+dynamicTopoFvMesh/edgeCollapse.C
+
 LIB = $(FOAM_LIBBIN)/libdynamicFvMesh
diff --git a/src/dynamicMesh/dynamicFvMesh/Make/options b/src/dynamicMesh/dynamicFvMesh/Make/options
index 697563799..b1a1bbb54 100644
--- a/src/dynamicMesh/dynamicFvMesh/Make/options
+++ b/src/dynamicMesh/dynamicFvMesh/Make/options
@@ -6,7 +6,9 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \
     -I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \
     $(WM_DECOMP_INC) \
-    -I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude
+    -I$(LIB_SRC)/dynamicMesh/meshMotion/fvMotionSolver/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/meshMotion/RBFMotionSolver/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/meshMotion/mesquiteMotionSolver/lnInclude
 
 LIB_LIBS = \
     -ltriSurface \
@@ -14,4 +16,6 @@ LIB_LIBS = \
     -ldynamicMesh \
     -lfiniteVolume \
     $(WM_DECOMP_LIBS) \
-    -lfvMotionSolver
+    -lfvMotionSolver \
+    -lRBFMotionSolver \
+    -lmesquiteMotionSolver
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H
new file mode 100644
index 000000000..a66e17efc
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMap.H
@@ -0,0 +1,162 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    changeMap
+
+Description
+    Accumulate topology change statistics
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    changeMapI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef changeMap_H
+#define changeMap_H
+
+#include "labelList.H"
+#include "FixedList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class changeMap Declaration
+\*---------------------------------------------------------------------------*/
+
+class changeMap
+{
+    // Sliver type index.
+    //  Type 1: Sliver
+    //  Type 2: Cap
+    //  Type 3: Spade
+    //  Type 4: Wedge
+    label type_;
+
+    // Data specific to sliver-type cells
+    label firstEdge_;
+    label secondEdge_;
+
+    // Data specific to cap-type cells
+    label apexPoint_;
+    label opposingFace_;
+
+    // Entities that were added during the operation.
+    //  - Add a master mapping for slaves.
+    //  - Masters get a map of -1.
+    List<FixedList<label,2> > addedPoints_;
+    List<FixedList<label,2> > addedEdges_;
+    List<FixedList<label,2> > addedFaces_;
+    List<FixedList<label,2> > addedCells_;
+
+public:
+
+    // Constructor
+    changeMap()
+    :
+        type_(-1),
+        firstEdge_(-1),
+        secondEdge_(-1),
+        apexPoint_(-1),
+        opposingFace_(-1),
+        addedPoints_(0),
+        addedEdges_(0),
+        addedFaces_(0),
+        addedCells_(0)
+    {}
+
+    //- Access
+
+        // Type
+        inline label& type();
+        inline label type() const;
+
+        // For sliver-type cells, opposite edges
+        // are identified for removal.
+        inline label& firstEdge();
+        inline label& secondEdge();
+
+        // For cap-type cells, the face requiring splitting
+        // is identified for removal.
+        inline label& apexPoint();
+        inline label& opposingFace();
+
+        // Added entities
+        inline void addPoint
+        (
+            const label pIndex,
+            const label master = -1
+        );
+
+        inline void addEdge
+        (
+            const label eIndex,
+            const label master = -1
+        );
+
+        inline void addFace
+        (
+            const label fIndex,
+            const label master = -1
+        );
+
+        inline void addCell
+        (
+            const label cIndex,
+            const label master = -1
+        );
+
+        // Return the list of added entities
+        inline const List<FixedList<label,2> >& addedPointList() const;
+        inline const List<FixedList<label,2> >& addedEdgeList() const;
+        inline const List<FixedList<label,2> >& addedFaceList() const;
+        inline const List<FixedList<label,2> >& addedCellList() const;
+
+    //- Operators
+
+        inline void operator=(const changeMap& rhs);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "changeMapI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H
new file mode 100644
index 000000000..a0a5ed875
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/changeMapI.H
@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Type
+inline label& changeMap::type()
+{
+    return type_;
+}
+
+
+inline label changeMap::type() const
+{
+    return type_;
+}
+
+
+// For sliver-type cells, opposite edges
+// are identified for removal.
+inline label& changeMap::firstEdge()
+{
+    return firstEdge_;
+}
+
+
+inline label& changeMap::secondEdge()
+{
+    return secondEdge_;
+}
+
+
+// For cap-type cells, the face requiring splitting
+// is identified for removal.
+inline label& changeMap::apexPoint()
+{
+    return apexPoint_;
+}
+
+
+inline label& changeMap::opposingFace()
+{
+    return opposingFace_;
+}
+
+
+// Added entities
+inline void changeMap::addPoint
+(
+    const label pIndex,
+    const label master
+)
+{
+    label curSize = addedPoints_.size();
+
+    addedPoints_.setSize(curSize + 1);
+
+    addedPoints_[curSize][0] = pIndex;
+    addedPoints_[curSize][1] = master;
+}
+
+
+inline void changeMap::addEdge
+(
+    const label eIndex,
+    const label master
+)
+{
+    label curSize = addedEdges_.size();
+
+    addedEdges_.setSize(curSize + 1);
+
+    addedEdges_[curSize][0] = eIndex;
+    addedEdges_[curSize][1] = master;
+}
+
+
+inline void changeMap::addFace
+(
+    const label fIndex,
+    const label master
+)
+{
+    label curSize = addedFaces_.size();
+
+    addedFaces_.setSize(curSize + 1);
+
+    addedFaces_[curSize][0] = fIndex;
+    addedFaces_[curSize][1] = master;
+}
+
+
+inline void changeMap::addCell
+(
+    const label cIndex,
+    const label master
+)
+{
+    label curSize = addedCells_.size();
+
+    addedCells_.setSize(curSize + 1);
+
+    addedCells_[curSize][0] = cIndex;
+    addedCells_[curSize][1] = master;
+}
+
+
+// Return an added point
+inline const List<FixedList<label,2> >&
+changeMap::addedPointList() const
+{
+    return addedPoints_;
+}
+
+
+// Return the list of added entities
+inline const List<FixedList<label,2> >&
+changeMap::addedEdgeList() const
+{
+    return addedEdges_;
+}
+
+
+inline const List<FixedList<label,2> >&
+changeMap::addedFaceList() const
+{
+    return addedFaces_;
+}
+
+
+inline const List<FixedList<label,2> >&
+changeMap::addedCellList() const
+{
+    return addedCells_;
+}
+
+
+inline void changeMap::operator=(const changeMap& rhs)
+{
+    type_ = rhs.type_;
+
+    firstEdge_    = rhs.firstEdge_;
+    secondEdge_   = rhs.secondEdge_;
+    apexPoint_    = rhs.apexPoint_;
+    opposingFace_ = rhs.opposingFace_;
+
+    addedPoints_  = rhs.addedPoints_;
+    addedEdges_   = rhs.addedEdges_;
+    addedFaces_   = rhs.addedFaces_;
+    addedCells_   = rhs.addedCells_;
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
new file mode 100644
index 000000000..0b95f162c
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.C
@@ -0,0 +1,3386 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    An implementation of dynamic changes to mesh-topology
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "dynamicTopoFvMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+#include "eMesh.H"
+#include "Stack.H"
+#include "triFace.H"
+#include "changeMap.H"
+#include "clockTime.H"
+#include "volFields.H"
+#include "MeshObject.H"
+#include "topoMapper.H"
+#include "mapPolyMesh.H"
+#include "MapFvFields.H"
+#include "SortableList.H"
+#include "motionSolver.H"
+#include "fvPatchFields.H"
+#include "fvsPatchFields.H"
+#include "lengthScaleEstimator.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(dynamicTopoFvMesh,0);
+
+addToRunTimeSelectionTable(dynamicFvMesh, dynamicTopoFvMesh, IOobject);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from IOobject
+dynamicTopoFvMesh::dynamicTopoFvMesh(const IOobject& io)
+:
+    dynamicFvMesh(io),
+    topoChangeFlag_(false),
+    dict_
+    (
+        IOobject
+        (
+            "dynamicMeshDict",
+            polyMesh::time().constant(),
+            (*this),
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    ),
+    mandatory_
+    (
+        dict_.subDict("dynamicTopoFvMesh").lookup("allOptionsMandatory")
+    ),
+    twoDMesh_(polyMesh::nGeometricD() == 2 ? true : false),
+    edgeRefinement_
+    (
+        dict_.subDict("dynamicTopoFvMesh").lookup("edgeRefinement")
+    ),
+    bandWidthReduction_(false),
+    interval_(1),
+    eMeshPtr_(NULL),
+    mapper_(NULL),
+    motionSolver_(NULL),
+    lengthEstimator_(NULL),
+    oldPoints_(polyMesh::points()),
+    points_(polyMesh::points()),
+    faces_(polyMesh::faces()),
+    owner_(polyMesh::faceOwner()),
+    neighbour_(polyMesh::faceNeighbour()),
+    cells_(primitiveMesh::cells()),
+    oldPatchSizes_(boundaryMesh().size(),0),
+    patchSizes_(boundaryMesh().size(),0),
+    oldPatchStarts_(boundaryMesh().size(),-1),
+    patchStarts_(boundaryMesh().size(),-1),
+    oldEdgePatchSizes_(boundaryMesh().size(),0),
+    edgePatchSizes_(boundaryMesh().size(),0),
+    oldEdgePatchStarts_(boundaryMesh().size(),-1),
+    edgePatchStarts_(boundaryMesh().size(),-1),
+    oldPatchNMeshPoints_(boundaryMesh().size(),-1),
+    patchNMeshPoints_(boundaryMesh().size(),-1),
+    nOldPoints_(primitiveMesh::nPoints()),
+    nPoints_(primitiveMesh::nPoints()),
+    nOldEdges_(0),
+    nEdges_(0),
+    nOldFaces_(primitiveMesh::nFaces()),
+    nFaces_(primitiveMesh::nFaces()),
+    nOldCells_(primitiveMesh::nCells()),
+    nCells_(primitiveMesh::nCells()),
+    nOldInternalFaces_(primitiveMesh::nInternalFaces()),
+    nInternalFaces_(primitiveMesh::nInternalFaces()),
+    nOldInternalEdges_(0),
+    nInternalEdges_(0),
+    maxModifications_(-1),
+    statistics_(0),
+    sliverThreshold_(0.1),
+    slicePairs_(0),
+    maxTetsPerEdge_(-1),
+    swapDeviation_(0.0),
+    allowTableResize_(false)
+{
+    // Check the size of owner/neighbour
+    if (owner_.size() != neighbour_.size())
+    {
+        // Size up to number of faces
+        neighbour_.setSize(nFaces_, -1);
+    }
+
+    const polyBoundaryMesh& boundary = polyMesh::boundaryMesh();
+
+    // Initialize the multiThreading environment
+    initializeThreadingEnvironment();
+
+    // Read optional parameters.
+    readOptionalParameters();
+
+    // Initialize patch-size information
+    for (label i = 0; i < boundaryMesh().size(); i++)
+    {
+        patchNMeshPoints_[i] = boundary[i].meshPoints().size();
+        oldPatchSizes_[i] = patchSizes_[i]  = boundary[i].size();
+        oldPatchStarts_[i] = patchStarts_[i] = boundary[i].start();
+        oldPatchNMeshPoints_[i] = patchNMeshPoints_[i];
+    }
+
+    // Open the tetMetric dynamic-link library (for 3D only)
+    loadMetric();
+
+    // Initialize edge-related connectivity structures
+    initEdges();
+
+    // Load the mesh-motion solver
+    loadMotionSolver();
+
+    // Load the field-mapper
+    loadFieldMapper();
+
+    // Set sizes for the reverse maps
+    reversePointMap_.setSize(nPoints_, -7);
+    reverseEdgeMap_.setSize(nEdges_, -7);
+    reverseFaceMap_.setSize(nFaces_, -7);
+    reverseCellMap_.setSize(nCells_, -7);
+
+    // Load the length-scale estimator,
+    // and read refinement options
+    loadLengthScaleEstimator();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+dynamicTopoFvMesh::~dynamicTopoFvMesh()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Insert the specified cell to the mesh.
+label dynamicTopoFvMesh::insertCell
+(
+    const cell& newCell,
+    const scalar lengthScale,
+    const label zoneID
+)
+{
+    label newCellIndex = cells_.size();
+
+    if (debug > 2)
+    {
+        Info << "Inserting cell: "
+             << newCellIndex << ": "
+             << newCell << endl;
+    }
+
+    cells_.append(newCell);
+
+    if (edgeRefinement_)
+    {
+        lengthScale_.append(lengthScale);
+    }
+
+    // Add to the zone if necessary
+    if (zoneID >= 0)
+    {
+        addedCellZones_.insert(newCellIndex, zoneID);
+    }
+
+    nCells_++;
+
+    return newCellIndex;
+}
+
+
+// Remove the specified cell from the mesh
+void dynamicTopoFvMesh::removeCell
+(
+    const label cIndex
+)
+{
+    if (debug > 2)
+    {
+        Info << "Removing cell: "
+             << cIndex << ": "
+             << cells_[cIndex]
+             << endl;
+    }
+
+    cells_[cIndex].clear();
+
+    if (edgeRefinement_)
+    {
+        lengthScale_[cIndex] = -1.0;
+    }
+
+    // Update the number of cells, and the reverse cell map
+    nCells_--;
+
+    if (cIndex < nOldCells_)
+    {
+        reverseCellMap_[cIndex] = -1;
+    }
+    else
+    {
+        // Store this information for the reOrdering stage
+        deletedCells_.insert(cIndex);
+    }
+
+    // Check if this cell was added to a zone
+    if (addedCellZones_.found(cIndex))
+    {
+        addedCellZones_.erase(cIndex);
+    }
+
+    // Check if the cell was added in the current morph, and delete
+    forAll(cellsFromPoints_, indexI)
+    {
+        if (cellsFromPoints_[indexI].index() == cIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex(indexI, cellsFromPoints_);
+            break;
+        }
+    }
+
+    forAll(cellsFromEdges_, indexI)
+    {
+        if (cellsFromEdges_[indexI].index() == cIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex(indexI, cellsFromEdges_);
+            break;
+        }
+    }
+
+    forAll(cellsFromFaces_, indexI)
+    {
+        if (cellsFromFaces_[indexI].index() == cIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex(indexI, cellsFromFaces_);
+            break;
+        }
+    }
+
+    forAll(cellsFromCells_, indexI)
+    {
+        if (cellsFromCells_[indexI].index() == cIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex(indexI, cellsFromCells_);
+            break;
+        }
+    }
+}
+
+
+// Utility method for face-insertion
+label dynamicTopoFvMesh::insertFace
+(
+    const label patch,
+    const face& newFace,
+    const label newOwner,
+    const label newNeighbour,
+    const label zoneID
+)
+{
+    // Append the specified face to each face-related list.
+    // Reordering is performed after all pending changes
+    // (flips, bisections, contractions, etc) have been made to the mesh
+    label newFaceIndex = faces_.size();
+
+    faces_.append(newFace);
+    owner_.append(newOwner);
+    neighbour_.append(newNeighbour);
+
+    if (debug > 2)
+    {
+        Info << "Inserting face: "
+             << newFaceIndex << ": "
+             << newFace
+             << " Owner: " << newOwner
+             << " Neighbour: " << newNeighbour;
+
+        Info << " Patch: ";
+
+        if (patch == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[patch].name() << endl;
+        }
+    }
+
+    // Keep track of added boundary faces in a separate hash-table
+    // This information will be required at the reordering stage
+    addedFacePatches_.insert(newFaceIndex,patch);
+
+    if (newNeighbour == -1)
+    {
+        // Modify patch information for this boundary face
+        patchSizes_[patch]++;
+
+        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        {
+            patchStarts_[i]++;
+        }
+    }
+    else
+    {
+        // Increment the number of internal faces,
+        // and subsequent patch-starts
+        nInternalFaces_++;
+
+        for (label i = 0; i < boundaryMesh().size(); i++)
+        {
+            patchStarts_[i]++;
+        }
+    }
+
+    // Add to the zone if explicitly specified
+    if (zoneID >= 0)
+    {
+        addedFaceZones_.insert(newFaceIndex, zoneID);
+    }
+
+    // Increment the total face count
+    nFaces_++;
+
+    return newFaceIndex;
+}
+
+
+// Remove the specified face from the mesh
+void dynamicTopoFvMesh::removeFace
+(
+    const label fIndex
+)
+{
+    if (debug > 2)
+    {
+        Info << "Removed face: "
+             << fIndex << ": "
+             << faces_[fIndex] << endl;
+    }
+
+    // Identify the patch for this face
+    label patch = whichPatch(fIndex);
+
+    if (patch >= 0)
+    {
+        // Modify patch information for this boundary face
+        patchSizes_[patch]--;
+
+        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        {
+            patchStarts_[i]--;
+        }
+    }
+    else
+    {
+        // Decrement the internal face count, and subsequent patch-starts
+        nInternalFaces_--;
+
+        forAll(patchStarts_, patchI)
+        {
+            patchStarts_[patchI]--;
+        }
+    }
+
+    // Clear entities.
+    faces_[fIndex].clear();
+    owner_[fIndex] = -1;
+    neighbour_[fIndex] = -1;
+    faceEdges_[fIndex].clear();
+
+    if (twoDMesh_)
+    {
+        // Remove from the stack as well
+        forAll(entityStack_, stackI)
+        {
+            stack(stackI).remove(fIndex);
+        }
+    }
+
+    // Update the reverse face-map, but only if this is a face that existed
+    // at time [n]. Added faces which are deleted during the topology change
+    // needn't be updated.
+    if (fIndex < nOldFaces_)
+    {
+        reverseFaceMap_[fIndex] = -1;
+    }
+    else
+    {
+        // Store this information for the reOrdering stage
+        deletedFaces_.insert(fIndex);
+    }
+
+    // Check and remove from the list of added face patches
+    if (addedFacePatches_.found(fIndex))
+    {
+        addedFacePatches_.erase(fIndex);
+    }
+
+    // Check if this face was added to a zone
+    if (addedFaceZones_.found(fIndex))
+    {
+        addedFaceZones_.erase(fIndex);
+    }
+
+    // Check if the face was added in the current morph, and delete
+    forAll(facesFromPoints_, indexI)
+    {
+        if (facesFromPoints_[indexI].index() == fIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex
+            (
+                indexI,
+                facesFromPoints_
+            );
+
+            break;
+        }
+    }
+
+    forAll(facesFromEdges_, indexI)
+    {
+        if (facesFromEdges_[indexI].index() == fIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex
+            (
+                indexI,
+                facesFromEdges_
+            );
+
+            break;
+        }
+    }
+
+    forAll(facesFromFaces_, indexI)
+    {
+        if (facesFromFaces_[indexI].index() == fIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex
+            (
+                indexI,
+                facesFromFaces_
+            );
+
+            break;
+        }
+    }
+
+    // Remove from the flipFaces list, if necessary
+    if (flipFaces_.found(fIndex))
+    {
+        flipFaces_.erase(fIndex);
+    }
+
+    // Decrement the total face-count
+    nFaces_--;
+}
+
+
+// Insert the specified edge to the mesh
+label dynamicTopoFvMesh::insertEdge
+(
+    const label patch,
+    const edge& newEdge,
+    const labelList& edgeFaces,
+    const labelList& edgePoints
+)
+{
+    label newEdgeIndex = edges_.size();
+
+    edges_.append(newEdge);
+    edgeFaces_.append(edgeFaces);
+
+    if (!twoDMesh_)
+    {
+        edgePoints_.append(edgePoints);
+    }
+
+    if (debug > 2)
+    {
+        Info << "Inserting edge: "
+             << newEdgeIndex << ": "
+             << newEdge;
+
+        Info << " Patch: ";
+
+        if (patch == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[patch].name() << endl;
+        }
+
+        if (!twoDMesh_)
+        {
+            if (findIndex(edgePoints, -1) != -1)
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "label dynamicTopoFvMesh::insertEdge\n"
+                    "(\n"
+                    "    const label patch,\n"
+                    "    const edge& newEdge,\n"
+                    "    const labelList& edgeFaces,\n"
+                    "    const labelList& edgePoints\n"
+                    ")"
+                )
+                    << " EdgePoints is incorrectly specified." << nl
+                    << " edgePoints: " << edgePoints << nl
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // Keep track of added edges in a separate hash-table
+    // This information will be required at the reordering stage
+    addedEdgePatches_.insert(newEdgeIndex,patch);
+
+    if (patch >= 0)
+    {
+        // Modify patch information for this boundary edge
+        edgePatchSizes_[patch]++;
+
+        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        {
+            edgePatchStarts_[i]++;
+        }
+    }
+    else
+    {
+        // Increment the number of internal edges, and subsequent patch-starts
+        nInternalEdges_++;
+
+        for (label i = 0; i < boundaryMesh().size(); i++)
+        {
+            edgePatchStarts_[i]++;
+        }
+    }
+
+    // Size-up the pointEdges list
+    if (!twoDMesh_)
+    {
+        meshOps::sizeUpList(newEdgeIndex, pointEdges_[newEdge[0]]);
+        meshOps::sizeUpList(newEdgeIndex, pointEdges_[newEdge[1]]);
+    }
+
+    // Increment the total edge count
+    nEdges_++;
+
+    return newEdgeIndex;
+}
+
+
+// Remove the specified edge from the mesh
+void dynamicTopoFvMesh::removeEdge
+(
+    const label eIndex
+)
+{
+    if (debug > 2)
+    {
+        Info << "Removing edge: "
+             << eIndex << ": "
+             << edges_[eIndex] << endl;
+    }
+
+    if (!twoDMesh_)
+    {
+        // Remove the edgePoints entry
+        edgePoints_[eIndex].clear();
+
+        // Size-down the pointEdges list
+        if (pointEdges_[edges_[eIndex][0]].size())
+        {
+            meshOps::sizeDownList(eIndex, pointEdges_[edges_[eIndex][0]]);
+        }
+
+        if (pointEdges_[edges_[eIndex][1]].size())
+        {
+            meshOps::sizeDownList(eIndex, pointEdges_[edges_[eIndex][1]]);
+        }
+
+        // Remove from the stack as well
+        forAll(entityStack_, stackI)
+        {
+            stack(stackI).remove(eIndex);
+        }
+    }
+
+    edges_[eIndex] = edge(-1, -1);
+    edgeFaces_[eIndex].clear();
+
+    // Identify the patch for this edge
+    label patch = whichEdgePatch(eIndex);
+
+    if (patch >= 0)
+    {
+        // Modify patch information for this boundary edge
+        edgePatchSizes_[patch]--;
+
+        for (label i = (patch + 1); i < boundaryMesh().size(); i++)
+        {
+            edgePatchStarts_[i]--;
+        }
+    }
+    else
+    {
+        // Decrement the internal edge count, and subsequent patch-starts
+        nInternalEdges_--;
+
+        forAll(edgePatchStarts_, patchI)
+        {
+            edgePatchStarts_[patchI]--;
+        }
+    }
+
+    // Update reverse edge-map, but only if this is an edge that existed
+    // at time [n]. Added edges which are deleted during the topology change
+    // needn't be updated.
+    if (eIndex < nOldEdges_)
+    {
+        reverseEdgeMap_[eIndex] = -1;
+    }
+    else
+    {
+        // Store this information for the reOrdering stage
+        deletedEdges_.insert(eIndex);
+    }
+
+    // Check and remove from the list of added edge patches
+    if (addedEdgePatches_.found(eIndex))
+    {
+        addedEdgePatches_.erase(eIndex);
+    }
+
+    // Decrement the total edge-count
+    nEdges_--;
+}
+
+
+// Insert the specified point to the mesh
+label dynamicTopoFvMesh::insertPoint
+(
+    const point& newPoint,
+    const point& oldPoint,
+    const labelList& mapPoints,
+    const label zoneID
+)
+{
+    // Add a new point to the end of the list
+    label newPointIndex = points_.size();
+
+    points_.append(newPoint);
+    oldPoints_.append(oldPoint);
+
+    if (debug > 2)
+    {
+        Info << "Inserting new point: "
+             << newPointIndex << ": "
+             << newPoint
+             << " and old point: "
+             << oldPoint
+             << "  Mapped from: "
+             << mapPoints << endl;
+    }
+
+    // Make a pointsFromPoints entry
+    meshOps::sizeUpList
+    (
+        objectMap(newPointIndex, mapPoints),
+        pointsFromPoints_
+    );
+
+    // Add an empty entry to pointEdges as well.
+    // This entry can be sized-up appropriately at a later stage.
+    if (!twoDMesh_)
+    {
+        pointEdges_.append(labelList(0));
+    }
+
+    // Add to the zone if necessary
+    if (zoneID >= 0)
+    {
+        addedPointZones_.insert(newPointIndex, zoneID);
+    }
+
+    nPoints_++;
+
+    return newPointIndex;
+}
+
+
+// Remove the specified point from the mesh
+void dynamicTopoFvMesh::removePoint
+(
+    const label pIndex
+)
+{
+    if (debug > 2)
+    {
+        Info << "Removing point: "
+             << pIndex << ": "
+             << points_[pIndex] << endl;
+    }
+
+    // Remove the point
+    // (or just make sure that it's never used anywhere else)
+    // points_[pIndex] = point();
+    // oldPoints_[pIndex] = point();
+
+    // Remove pointEdges as well
+    if (!twoDMesh_)
+    {
+        pointEdges_[pIndex].clear();
+    }
+
+    // Update the reverse point map
+    if (pIndex < nOldPoints_)
+    {
+        reversePointMap_[pIndex] = -1;
+    }
+    else
+    {
+        deletedPoints_.insert(pIndex);
+    }
+
+    // Check if this point was added to a zone
+    if (addedPointZones_.found(pIndex))
+    {
+        addedPointZones_.erase(pIndex);
+    }
+
+    // Check if the point was added in the current morph, and delete
+    forAll(pointsFromPoints_, indexI)
+    {
+        if (pointsFromPoints_[indexI].index() == pIndex)
+        {
+            // Remove entry from the list
+            meshOps::removeIndex(indexI, pointsFromPoints_);
+            break;
+        }
+    }
+
+    // Decrement the total point-count
+    nPoints_--;
+}
+
+
+// Utility method to build edgePoints for an edge [3D].
+// Assumes that edgeFaces information is consistent.
+void dynamicTopoFvMesh::buildEdgePoints
+(
+    const label eIndex,
+    const label checkIndex
+)
+{
+    bool found = false;
+    label faceIndex = -1, cellIndex = -1;
+    label otherPoint = -1, nextPoint = -1;
+
+    // Obtain references
+    const edge& edgeToCheck = edges_[eIndex];
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    // Re-size the list first
+    labelList& ePoints = edgePoints_[eIndex];
+    ePoints.setSize(eFaces.size(), -1);
+
+    if (whichEdgePatch(eIndex) == -1)
+    {
+        // Internal edge.
+        // Pick the first face and start with that
+        faceIndex = eFaces[0];
+    }
+    else
+    {
+        // Need to find a properly oriented start-face
+        forAll(eFaces, faceI)
+        {
+            if (whichPatch(eFaces[faceI]) > -1)
+            {
+                meshOps::findIsolatedPoint
+                (
+                    faces_[eFaces[faceI]],
+                    edgeToCheck,
+                    otherPoint,
+                    nextPoint
+                );
+
+                if (nextPoint == edgeToCheck[checkIndex])
+                {
+                    faceIndex = eFaces[faceI];
+                    break;
+                }
+            }
+        }
+    }
+
+    // Shuffle vertices to appear in CCW order
+    forAll(ePoints, indexI)
+    {
+        meshOps::findIsolatedPoint
+        (
+            faces_[faceIndex],
+            edgeToCheck,
+            otherPoint,
+            nextPoint
+        );
+
+        // Add the isolated point
+        ePoints[indexI] = otherPoint;
+
+        // Figure out how this edge is oriented.
+        if (nextPoint == edgeToCheck[checkIndex])
+        {
+            // Counter-clockwise. Pick the owner.
+            cellIndex = owner_[faceIndex];
+        }
+        else
+        if (whichPatch(faceIndex) == -1)
+        {
+            // Clockwise. Pick the neighbour.
+            cellIndex = neighbour_[faceIndex];
+        }
+        else
+        {
+            // Looks like we've hit a boundary face. Break out.
+            break;
+        }
+
+        const cell& cellToCheck = cells_[cellIndex];
+
+        found = false;
+
+        // Assuming tet-cells,
+        // Loop through edgeFaces and get the next face
+        forAll(eFaces, faceI)
+        {
+            if
+            (
+                eFaces[faceI] != faceIndex
+             && eFaces[faceI] == cellToCheck[0]
+            )
+            {
+                faceIndex = cellToCheck[0];
+                found = true; break;
+            }
+
+            if
+            (
+                eFaces[faceI] != faceIndex
+             && eFaces[faceI] == cellToCheck[1]
+            )
+            {
+                faceIndex = cellToCheck[1];
+                found = true; break;
+            }
+
+            if
+            (
+                eFaces[faceI] != faceIndex
+             && eFaces[faceI] == cellToCheck[2]
+            )
+            {
+                faceIndex = cellToCheck[2];
+                found = true; break;
+            }
+
+            if
+            (
+                eFaces[faceI] != faceIndex
+             && eFaces[faceI] == cellToCheck[3]
+            )
+            {
+                faceIndex = cellToCheck[3];
+                found = true; break;
+            }
+        }
+
+        if (!found)
+        {
+            Info << "edgeFaces: " << endl;
+
+            forAll(eFaces, faceI)
+            {
+                Info << " Face: " << eFaces[faceI]
+                     << ":: " << faces_[eFaces[faceI]]
+                     << " Owner: " << owner_[eFaces[faceI]]
+                     << " Neighbour: " << neighbour_[eFaces[faceI]]
+                     << endl;
+            }
+
+            writeVTK("vRingEdgeFaces", eFaces, 2);
+            writeVTK("vRingCellToCheck", cellIndex);
+
+            // Something's terribly wrong
+            FatalErrorIn
+            (
+                "\n"
+                "void dynamicTopoFvMesh::buildEdgePoints\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    const label checkIndex\n"
+                ")"
+            )
+                << " Failed to determine a vertex ring. " << nl
+                << " edgeFaces connectivity is inconsistent. " << nl
+                << " Edge: " << eIndex << ":: " << edgeToCheck << nl
+                << " edgeFaces: " << eFaces << nl
+                << " Patch: " << whichEdgePatch(eIndex) << nl
+                << " cellIndex: " << cellIndex
+                << " :: " << cellToCheck << nl
+                << " Current edgePoints: " << ePoints
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// Test an edge / face for proximity with other faces on proximity patches
+// and return the scalar distance to an oppositely-oriented face.
+scalar dynamicTopoFvMesh::testProximity
+(
+    const label index,
+    label& proximityFace
+) const
+{
+    scalar proxDistance = GREAT, testStep = 0.0;
+    vector gCentre = vector::zero, gNormal = vector::zero;
+
+    if (twoDMesh_)
+    {
+        // Obtain the face-normal.
+        meshOps::faceNormal(faces_[index], points_, gNormal);
+
+        // Obtain the face centre.
+        meshOps::faceCentre(faces_[index], points_, gCentre);
+
+        // Fetch the edge
+        const edge& edgeToCheck = edges_[getTriBoundaryEdge(index)];
+
+        // Calculate a test step-size
+        testStep =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck.start()],
+                points_[edgeToCheck.end()]
+            ).mag()
+        );
+    }
+    else
+    {
+        const edge& edgeToCheck = edges_[index];
+        const labelList& eFaces = edgeFaces_[index];
+
+        linePointRef lpr
+        (
+            points_[edgeToCheck.start()],
+            points_[edgeToCheck.end()]
+        );
+
+        // Obtain the edge centre.
+        gCentre = lpr.centre();
+
+        // Obtain the edge-normal
+        forAll(eFaces, faceI)
+        {
+            if (neighbour_[eFaces[faceI]] == -1)
+            {
+                // Obtain the normal.
+                vector gTmp;
+
+                meshOps::faceNormal
+                (
+                    faces_[eFaces[faceI]],
+                    points_,
+                    gTmp
+                );
+
+                gNormal += gTmp;
+            }
+        }
+
+        // Calculate a test step-size
+        testStep = lpr.mag();
+    }
+
+    // Normalize
+    gNormal /= (mag(gNormal) + VSMALL);
+
+    // Test for proximity, and mark slice-pairs
+    // is the distance is below threshold.
+    if
+    (
+        lengthEstimator().testProximity
+        (
+            gCentre,
+            gNormal,
+            testStep,
+            proximityFace,
+            proxDistance
+        )
+    )
+    {
+        labelPair proxPoints(-1, -1);
+        bool foundPoint = false;
+
+        if (twoDMesh_)
+        {
+            proxPoints.first() = index;
+            proxPoints.second() = proximityFace;
+
+            if
+            (
+                (faces_[index].size() == 4) &&
+                (polyMesh::faces()[proximityFace].size() == 4)
+            )
+            {
+                foundPoint = true;
+            }
+        }
+        else
+        {
+            const edge& thisEdge = edges_[index];
+            const face& proxFace = polyMesh::faces()[proximityFace];
+
+            // Check if any points on this face are still around.
+            // If yes, mark one of them as the end point
+            // for Dijkstra's algorithm. The start point will be a point
+            // on this edge.
+            proxPoints.first() = thisEdge[0];
+
+            forAll(proxFace, pointI)
+            {
+                if (reversePointMap_[proxFace[pointI]] != -1)
+                {
+                    proxPoints.second() = proxFace[pointI];
+                    foundPoint = true;
+                    break;
+                }
+            }
+        }
+
+        if (foundPoint)
+        {
+            // Lock the edge mutex
+            entityMutex_[1].lock();
+
+            label newSize = slicePairs_.size() + 1;
+
+            // Const-cast slicePairs for resize
+            List<labelPair>& sP = const_cast<List<labelPair>&>(slicePairs_);
+
+            // Add this entry as a candidate for mesh slicing.
+            sP.setSize(newSize, proxPoints);
+
+            // Unlock the edge mutex
+            entityMutex_[1].unlock();
+        }
+    }
+
+    return proxDistance;
+}
+
+
+// Calculate the edge length-scale for the mesh
+void dynamicTopoFvMesh::calculateLengthScale(bool dump)
+{
+    if (!edgeRefinement_)
+    {
+        return;
+    }
+
+    Switch dumpLengthScale(false);
+
+    const dictionary& meshDict = dict_.subDict("dynamicTopoFvMesh");
+
+    if (meshDict.found("dumpLengthScale") || mandatory_)
+    {
+        dumpLengthScale = readBool(meshDict.lookup("dumpLengthScale"));
+    }
+
+    autoPtr<volScalarField> lsfPtr(NULL);
+
+    if (dumpLengthScale && time().outputTime() && dump)
+    {
+        lsfPtr.set
+        (
+            new volScalarField
+            (
+                IOobject
+                (
+                    "lengthScale",
+                    time().timeName(),
+                    *this,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                *this,
+                dimensionedScalar("scalar", dimLength, 0)
+            )
+        );
+    }
+
+    // Bail-out if a dumping was not requested in dictionary.
+    if (dump && !dumpLengthScale)
+    {
+        return;
+    }
+
+    // Size the field and calculate length-scale
+    lengthScale_.setSize(nCells_, 0.0);
+
+    lengthEstimator().calculateLengthScale(lengthScale_);
+
+    // Check if length-scale is to be dumped to disk.
+    if (dumpLengthScale && time().outputTime() && dump)
+    {
+        // Obtain length-scale values from the mesh
+        lsfPtr->internalField() = lengthScale_;
+
+        lsfPtr->write();
+    }
+}
+
+
+// Read optional dictionary parameters
+void dynamicTopoFvMesh::readOptionalParameters(bool reRead)
+{
+    // Read from disk
+    dict_.readIfModified();
+
+    // Enable/disable run-time debug level
+    if (dict_.found("debug") || mandatory_)
+    {
+        debug = readLabel(dict_.lookup("debug"));
+    }
+    else
+    {
+        debug = 0;
+    }
+
+    // Set debug option for underlying classes as well.
+    lengthScaleEstimator::debug = debug;
+
+    if (debug > 2)
+    {
+        fvMesh::debug = true;
+        polyMesh::debug = true;
+    }
+
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+    // Re-read edge-refinement options, if necessary
+    if (edgeRefinement_ && reRead)
+    {
+        lengthEstimator().readRefinementOptions
+        (
+            meshSubDict.subDict("refinementOptions"),
+            true,
+            mandatory_
+        );
+    }
+
+    // Read re-mesh interval
+    if (meshSubDict.found("interval") || mandatory_)
+    {
+        interval_ = readLabel(meshSubDict.lookup("interval"));
+    }
+    else
+    {
+        interval_ = 1;
+    }
+
+    // Update bandwidth reduction switch
+    if (meshSubDict.found("bandwidthReduction") || mandatory_)
+    {
+        bandWidthReduction_.readIfPresent("bandwidthReduction", meshSubDict);
+    }
+
+    // Update threshold for sliver cells
+    if (meshSubDict.found("sliverThreshold") || mandatory_)
+    {
+        sliverThreshold_ = readScalar(meshSubDict.lookup("sliverThreshold"));
+
+        if (sliverThreshold_ > 1.0 || sliverThreshold_ < 0.0)
+        {
+            FatalErrorIn("void dynamicTopoFvMesh::readOptionalParameters()")
+                << " Sliver threshold out of range [0..1]"
+                << abort(FatalError);
+        }
+    }
+
+    // Update limit for max number of bisections / collapses
+    if (meshSubDict.found("maxModifications") || mandatory_)
+    {
+        maxModifications_ = readLabel(meshSubDict.lookup("maxModifications"));
+    }
+
+    // Update limit for swap on curved surfaces
+    if (meshSubDict.found("swapDeviation") || mandatory_)
+    {
+        swapDeviation_ = readScalar(meshSubDict.lookup("swapDeviation"));
+
+        if (swapDeviation_ > 1.0 || swapDeviation_ < 0.0)
+        {
+            FatalErrorIn("void dynamicTopoFvMesh::readOptionalParameters()")
+                << " Swap deviation out of range [0..1]"
+                << abort(FatalError);
+        }
+    }
+
+    // For tetrahedral meshes...
+    if (!twoDMesh_)
+    {
+        // Check if swapping is to be avoided on any patches
+        if (meshSubDict.found("noSwapPatches") || mandatory_)
+        {
+            wordList noSwapPatches =
+            (
+                meshSubDict.subDict("noSwapPatches").toc()
+            );
+
+            noSwapPatchIDs_.setSize(noSwapPatches.size());
+
+            label indexI = 0;
+
+            forAll(noSwapPatches, wordI)
+            {
+                const word& patchName = noSwapPatches[wordI];
+
+                noSwapPatchIDs_[indexI++] =
+                (
+                    boundaryMesh().findPatchID(patchName)
+                );
+            }
+        }
+
+        // Check if a limit has been imposed on maxTetsPerEdge
+        if (meshSubDict.found("maxTetsPerEdge") || mandatory_)
+        {
+            maxTetsPerEdge_ = readLabel(meshSubDict.lookup("maxTetsPerEdge"));
+        }
+        else
+        {
+            maxTetsPerEdge_ = 7;
+        }
+
+        // Check if programming tables can be resized at runtime
+        if (meshSubDict.found("allowTableResize") || mandatory_)
+        {
+            allowTableResize_ =
+            (
+                readBool(meshSubDict.lookup("allowTableResize"))
+            );
+        }
+        else
+        {
+            allowTableResize_ = false;
+        }
+    }
+}
+
+
+// Initialize edge related connectivity lists
+void dynamicTopoFvMesh::initEdges()
+{
+    // Initialize eMesh, and copy to local lists
+    eMeshPtr_.set(new eMesh(*this));
+
+    // Obtain information
+    nEdges_ = eMeshPtr_->nEdges();
+    nInternalEdges_ = eMeshPtr_->nInternalEdges();
+    edgePatchSizes_ = eMeshPtr_->boundary().patchSizes();
+    edgePatchStarts_ = eMeshPtr_->boundary().patchStarts();
+
+    // Set old edge information
+    nOldEdges_ = nEdges_;
+    nOldInternalEdges_ = nInternalEdges_;
+    oldEdgePatchSizes_ = edgePatchSizes_;
+    oldEdgePatchStarts_ = edgePatchStarts_;
+
+    // Set local lists with edge connectivity information
+    edges_ = eMeshPtr_->edges();
+    edgeFaces_ = eMeshPtr_->edgeFaces();
+    faceEdges_ = eMeshPtr_->faceEdges();
+
+    if (!twoDMesh_)
+    {
+        pointEdges_ = eMeshPtr_->pointEdges();
+        edgePoints_ = eMeshPtr_->edgePoints();
+    }
+
+    // Clear out unwanted eMesh connectivity
+    eMeshPtr_->clearOut();
+}
+
+
+// Load the mesh-quality metric from the library
+void dynamicTopoFvMesh::loadMetric()
+{
+    if (twoDMesh_)
+    {
+        return;
+    }
+
+    // Specify the dictionary we would be looking in...
+    const dictionary& meshDict = dict_.subDict("dynamicTopoFvMesh");
+
+    // Select an appropriate metric
+    tetMetric_ = tetMetric::New(meshDict, meshDict.lookup("tetMetric"));
+}
+
+
+// Load the mesh-motion solver
+void dynamicTopoFvMesh::loadMotionSolver()
+{
+    if (motionSolver_.valid())
+    {
+        FatalErrorIn
+        (
+            "void dynamicTopoFvMesh::loadMotionSolver() "
+        ) << nl << " Motion solver already loaded. "
+          << abort(FatalError);
+    }
+    else
+    if (dict_.found("solver"))
+    {
+        motionSolver_ = motionSolver::New(*this);
+    }
+}
+
+
+// Load the field mapper
+void dynamicTopoFvMesh::loadFieldMapper()
+{
+    if (mapper_.valid())
+    {
+        FatalErrorIn
+        (
+            "void dynamicTopoFvMesh::loadFieldMapper() "
+        ) << nl << " Field mapper already loaded. "
+          << abort(FatalError);
+    }
+    else
+    {
+        mapper_.set(new topoMapper(*this, dict_));
+    }
+}
+
+
+// Load the length scale estimator
+void dynamicTopoFvMesh::loadLengthScaleEstimator()
+{
+    if (edgeRefinement_)
+    {
+        if (lengthEstimator_.valid())
+        {
+            FatalErrorIn
+            (
+                "void dynamicTopoFvMesh::loadLengthScaleEstimator() "
+            ) << nl << " Length scale estimator already loaded. "
+              << abort(FatalError);
+        }
+        else
+        {
+            lengthEstimator_.set
+            (
+                new lengthScaleEstimator(*this)
+            );
+        }
+
+        // Read options
+        lengthEstimator().readRefinementOptions
+        (
+            dict_.subDict("dynamicTopoFvMesh").subDict("refinementOptions"),
+            false,
+            mandatory_
+        );
+    }
+}
+
+
+// Initialize the threading environment.
+//  - Provides an override option to avoid reading from the dictionary.
+void dynamicTopoFvMesh::initializeThreadingEnvironment
+(
+    const label specThreads
+)
+{
+    // Initialize an IOobject for the IOmultiThreader object
+    IOobject io
+    (
+        "threader",
+        this->time().timeName(),
+        (*this),
+        IOobject::NO_READ,
+        IOobject::NO_WRITE,
+        true
+    );
+
+    if (specThreads > 0)
+    {
+        threader_.set(new IOmultiThreader(io, specThreads));
+    }
+    else
+    {
+        if (dict_.subDict("dynamicTopoFvMesh").found("threads") || mandatory_)
+        {
+            threader_.set
+            (
+                new IOmultiThreader
+                (
+                    io,
+                    readLabel
+                    (
+                        dict_.subDict("dynamicTopoFvMesh").lookup("threads")
+                    )
+                )
+            );
+        }
+        else
+        {
+            threader_.set(new IOmultiThreader(io, 1));
+        }
+    }
+
+    // Get the number of threads and allocate threadHandlers
+    label nThreads = threader_->getNumThreads();
+
+    if (nThreads == 1)
+    {
+        handlerPtr_.setSize(1);
+
+        handlerPtr_.set
+        (
+            0,
+            new meshHandler(*this, threader())
+        );
+
+        handlerPtr_[0].setMaster();
+
+        // Size the stacks
+        entityStack_.setSize(1);
+    }
+    else
+    {
+        // Index '0' is master, rest are slaves
+        handlerPtr_.setSize(nThreads + 1);
+
+        // Size the stacks
+        entityStack_.setSize(nThreads + 1);
+
+        forAll(handlerPtr_, threadI)
+        {
+            handlerPtr_.set
+            (
+                threadI,
+                new meshHandler(*this, threader())
+            );
+
+            if (threadI == 0)
+            {
+                handlerPtr_[0].setID(-1);
+                handlerPtr_[0].setMaster();
+            }
+            else
+            {
+                handlerPtr_[threadI].setID(threader_->getID(threadI-1));
+                handlerPtr_[threadI].setSlave();
+            }
+        }
+    }
+}
+
+
+// 2D Edge-swapping engine
+void dynamicTopoFvMesh::swap2DEdges(void *argument)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::START);
+    }
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Figure out which thread this is...
+    label tIndex = mesh.self();
+
+    // Set the timer
+    clockTime sTimer;
+
+    bool reported = false;
+    label stackSize = mesh.stack(tIndex).size();
+    scalar interval = mesh.reportInterval(), oIndex = 0.0, nIndex = 0.0;
+
+    oIndex = ::floor(sTimer.elapsedTime() / interval);
+
+    // Pick items off the stack
+    while (!mesh.stack(tIndex).empty())
+    {
+        // Report progress
+        if (thread->master())
+        {
+            // Update the index, if its changed
+            nIndex = ::floor(sTimer.elapsedTime() / interval);
+
+            if ((nIndex - oIndex) > VSMALL)
+            {
+                oIndex = nIndex;
+
+                scalar percent =
+                (
+                    100.0 -
+                    (
+                        (100.0 * mesh.stack(tIndex).size())
+                      / (stackSize + VSMALL)
+                    )
+                );
+
+                Info << "  Swap Progress: " << percent << "% :"
+                     << "  Total: " << mesh.status(1)
+                     << "             \r"
+                     << flush;
+
+                reported = true;
+            }
+        }
+
+        // Retrieve the index for this face
+        label fIndex = mesh.stack(tIndex).pop();
+
+        // Perform a Delaunay test and check if a flip is necesary.
+        bool failed = mesh.testDelaunay(fIndex);
+
+        if (failed)
+        {
+            if (thread->master())
+            {
+                // Swap this face.
+                mesh.swapQuadFace(fIndex);
+            }
+            else
+            {
+                // Push this on to the master stack
+                mesh.stack(0).push(fIndex);
+            }
+        }
+    }
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::STOP);
+    }
+
+    if (reported)
+    {
+        Info << "  Swap Progress: 100% :"
+             << "  Total: " << mesh.status(1)
+             << "             \r"
+             << endl;
+    }
+}
+
+
+// 3D Edge-swapping engine
+void dynamicTopoFvMesh::swap3DEdges
+(
+    void *argument
+)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::START);
+    }
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Figure out which thread this is...
+    label tIndex = mesh.self();
+
+    // Dynamic programming variables
+    labelList m;
+    PtrList<scalarListList> Q;
+    PtrList<labelListList> K, triangulations;
+
+    // Allocate dynamic programming tables
+    mesh.initTables(m, Q, K, triangulations);
+
+    // Set the timer
+    clockTime sTimer;
+
+    bool reported = false;
+    label stackSize = mesh.stack(tIndex).size();
+    scalar interval = mesh.reportInterval(), oIndex = 0.0, nIndex = 0.0;
+
+    oIndex = ::floor(sTimer.elapsedTime() / interval);
+
+    // Pick edges off the stack
+    while (!mesh.stack(tIndex).empty())
+    {
+        // Report progress
+        if (thread->master())
+        {
+            // Update the index, if its changed
+            nIndex = ::floor(sTimer.elapsedTime() / interval);
+
+            if ((nIndex - oIndex) > VSMALL)
+            {
+                oIndex = nIndex;
+
+                scalar percent =
+                (
+                    100.0 -
+                    (
+                        (100.0 * mesh.stack(tIndex).size())
+                      / (stackSize + VSMALL)
+                    )
+                );
+
+                Info << "  Swap Progress: " << percent << "% :"
+                     << "  Surface: " << mesh.status(2)
+                     << ", Total: " << mesh.status(1)
+                     << "             \r"
+                     << flush;
+
+                reported = true;
+            }
+        }
+
+        // Retrieve an edge from the stack
+        label eIndex = mesh.stack(tIndex).pop();
+
+        // Compute the minimum quality of cells around this edge
+        scalar minQuality = mesh.computeMinQuality(eIndex);
+
+        // Check if this edge is on a bounding curve
+        if (mesh.checkBoundingCurve(eIndex))
+        {
+            continue;
+        }
+
+        // Fill the dynamic programming tables
+        if (mesh.fillTables(eIndex, minQuality, m, Q, K, triangulations))
+        {
+            // Check if edge-swapping is required.
+            if (mesh.checkQuality(eIndex, m, Q, minQuality))
+            {
+                if (thread->master())
+                {
+                    // Remove this edge according to the swap sequence
+                    mesh.removeEdgeFlips(eIndex, minQuality, K, triangulations);
+                }
+                else
+                {
+                    // Push this on to the master stack
+                    mesh.stack(0).push(eIndex);
+                }
+            }
+        }
+    }
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::STOP);
+    }
+
+    if (reported)
+    {
+        Info << "  Swap Progress: 100% :"
+             << "  Surface: " << mesh.status(2)
+             << ", Total: " << mesh.status(1)
+             << "             \r"
+             << endl;
+    }
+}
+
+
+// Edge refinement engine
+void dynamicTopoFvMesh::edgeRefinementEngine
+(
+    void *argument
+)
+{
+    // Loop through all edges and bisect/collapse by the criterion:
+    // Bisect when edge-length > ratioMax_*lengthScale
+    // Collapse when edge-length < ratioMin_*lengthScale
+
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::START);
+    }
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Figure out which thread this is...
+    label tIndex = mesh.self();
+
+    // Set the timer
+    clockTime sTimer;
+
+    bool reported = false;
+    label stackSize = mesh.stack(tIndex).size();
+    scalar interval = mesh.reportInterval(), oIndex = 0.0, nIndex = 0.0;
+
+    oIndex = ::floor(sTimer.elapsedTime() / interval);
+
+    while (!mesh.stack(tIndex).empty())
+    {
+        // Update the index, if its changed
+        // Report progress
+        if (thread->master())
+        {
+            nIndex = ::floor(sTimer.elapsedTime() / interval);
+
+            if ((nIndex - oIndex) > VSMALL)
+            {
+                oIndex = nIndex;
+
+                scalar percent =
+                (
+                    100.0 -
+                    (
+                        (100.0 * mesh.stack(tIndex).size())
+                      / (stackSize + VSMALL)
+                    )
+                );
+
+                Info << "  Refinement Progress: " << percent << "% :"
+                     << "  Bisections: " << mesh.status(3)
+                     << ", Collapses: " << mesh.status(4)
+                     << ", Total: " << mesh.status(0)
+                     << "             \r"
+                     << flush;
+
+                reported = true;
+            }
+        }
+
+        // Retrieve an entity from the stack
+        label eIndex = mesh.stack(tIndex).pop();
+
+        if (mesh.checkBisection(eIndex))
+        {
+            if (thread->master())
+            {
+                // Bisect this edge
+                mesh.bisectEdge(eIndex);
+            }
+            else
+            {
+                // Push this on to the master stack
+                mesh.stack(0).push(eIndex);
+            }
+        }
+        else
+        if (mesh.checkCollapse(eIndex))
+        {
+            if (thread->master())
+            {
+                // Collapse this edge
+                mesh.collapseEdge(eIndex);
+            }
+            else
+            {
+                // Push this on to the master stack
+                mesh.stack(0).push(eIndex);
+            }
+        }
+    }
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::STOP);
+    }
+
+    if (reported)
+    {
+        Info << "  Refinement Progress: 100% :"
+             << "  Bisections: " << mesh.status(3)
+             << ", Collapses: " << mesh.status(4)
+             << ", Total: " << mesh.status(0)
+             << "             \r"
+             << endl;
+    }
+}
+
+
+// Remove 2D sliver cells from the mesh
+void dynamicTopoFvMesh::remove2DSlivers()
+{
+    // Sort by sliver-quality.
+    labelList cIndices(thresholdSlivers_.toc());
+    SortableList<scalar> values(cIndices.size());
+
+    // Fill-in values to sort by...
+    forAll(cIndices, indexI)
+    {
+        values[indexI] = thresholdSlivers_[cIndices[indexI]];
+    }
+
+    // Explicitly sort by quality value.
+    values.sort();
+
+    const labelList& indices = values.indices();
+
+    if (debug)
+    {
+        if (thresholdSlivers_.size())
+        {
+            Info << "Sliver list: " << endl;
+
+            forAll(indices, indexI)
+            {
+                label cIndex = cIndices[indices[indexI]];
+
+                Info << " Cell: " << cIndex
+                     << " Quality: " << thresholdSlivers_[cIndex]
+                     << endl;
+            }
+
+            if (debug > 1)
+            {
+                writeVTK("sliverCells", cIndices, 3);
+            }
+        }
+    }
+
+    forAll(indices, indexI)
+    {
+        // Fetch the cell
+        label cIndex = cIndices[indices[indexI]];
+
+        // Ensure that this cell actually exists.
+        if (cells_[cIndex].empty())
+        {
+            continue;
+        }
+
+        const cell& cellToCheck = cells_[cIndex];
+
+        // Find an appropriate quad-face
+        label fIndex = -1;
+
+        forAll(cellToCheck, faceI)
+        {
+            if (faces_[cellToCheck[faceI]].size() == 4)
+            {
+                fIndex = cellToCheck[faceI];
+                break;
+            }
+        }
+
+        // Find the prism faces
+        FixedList<label,2> cBdyIndex(-1), cIntIndex(-1);
+        FixedList<face,2> cBdyFace, cIntFace;
+
+        meshOps::findPrismFaces
+        (
+            fIndex,
+            cIndex,
+            faces_,
+            cells_,
+            neighbour_,
+            cBdyFace,
+            cBdyIndex,
+            cIntFace,
+            cIntIndex
+        );
+
+        if (debug > 1)
+        {
+            InfoIn("void dynamicTopoFvMesh::remove2DSlivers()")
+                << nl
+                << " Considering cell: " << cIndex
+                << ":: " << cells_[cIndex]
+                << " for sliver removal."
+                << " Using face: " << fIndex
+                << ":: " << faces_[fIndex]
+                << endl;
+        }
+
+        label triFace = cBdyIndex[0], triEdge = -1;
+
+        // Find the common-edge between quad-tri faces
+        meshOps::findCommonEdge
+        (
+            fIndex,
+            triFace,
+            faceEdges_,
+            triEdge
+        );
+
+        // Find the isolated point.
+        label ptIndex = -1, nextPtIndex = -1;
+
+        const edge& edgeToCheck = edges_[triEdge];
+
+        meshOps::findIsolatedPoint
+        (
+            faces_[triFace],
+            edgeToCheck,
+            ptIndex,
+            nextPtIndex
+        );
+
+        // Determine the interior faces connected to each edge-point.
+        label firstFace = -1, secondFace = -1;
+
+        if (cIntFace[0].which(edgeToCheck[0]) > -1)
+        {
+            firstFace  = cIntIndex[0];
+            secondFace = cIntIndex[1];
+        }
+        else
+        {
+            firstFace  = cIntIndex[1];
+            secondFace = cIntIndex[0];
+        }
+
+        point ec =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck[0]],
+                points_[edgeToCheck[1]]
+            ).centre()
+        );
+
+        FixedList<vector, 2> p(vector::zero), q(vector::zero);
+        FixedList<scalar, 2> proj(0.0);
+
+        // Find the projection on the edge.
+        forAll(edgeToCheck, pointI)
+        {
+            p[pointI] = (points_[ptIndex] - points_[edgeToCheck[pointI]]);
+            q[pointI] = (ec - points_[edgeToCheck[pointI]]);
+
+            q[pointI] /= (mag(q[pointI]) + VSMALL);
+
+            proj[pointI] = (p[pointI] & q[pointI]);
+        }
+
+        // Take action based on the magnitude of the projection.
+        if (mag(proj[0]) < VSMALL)
+        {
+            if (collapseQuadFace(firstFace).type() > 0)
+            {
+                statistics_[7]++;
+            }
+
+            continue;
+        }
+
+        if (mag(proj[1]) < VSMALL)
+        {
+            if (collapseQuadFace(secondFace).type() > 0)
+            {
+                statistics_[7]++;
+            }
+
+            continue;
+        }
+
+        if (proj[0] > 0.0 && proj[1] < 0.0)
+        {
+            changeMap map = bisectQuadFace(firstFace, changeMap());
+
+            // Loop through added faces, and collapse
+            // the appropriate one
+            const List<FixedList<label,2> >& aF = map.addedFaceList();
+
+            forAll(aF, faceI)
+            {
+                if
+                (
+                    (owner_[aF[faceI][0]] == cIndex) &&
+                    (aF[faceI][0] != firstFace)
+                )
+                {
+                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    {
+                        statistics_[7]++;
+                    }
+
+                    break;
+                }
+            }
+
+            continue;
+        }
+
+        if (proj[0] < 0.0 && proj[1] > 0.0)
+        {
+            changeMap map = bisectQuadFace(secondFace, changeMap());
+
+            // Loop through added faces, and collapse
+            // the appropriate one
+            const List<FixedList<label,2> >& aF = map.addedFaceList();
+
+            forAll(aF, faceI)
+            {
+                if
+                (
+                    (owner_[aF[faceI][0]] == cIndex) &&
+                    (aF[faceI][0] != secondFace)
+                )
+                {
+                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    {
+                        statistics_[7]++;
+                    }
+
+                    break;
+                }
+            }
+
+            continue;
+        }
+
+        if (proj[0] > 0.0 && proj[1] > 0.0)
+        {
+            changeMap map = bisectQuadFace(fIndex, changeMap());
+
+            // Loop through added faces, and collapse
+            // the appropriate one
+            const List<FixedList<label,2> >& aF = map.addedFaceList();
+
+            forAll(aF, faceI)
+            {
+                if
+                (
+                    (owner_[aF[faceI][0]] == cIndex) &&
+                    (aF[faceI][0] != fIndex)
+                )
+                {
+                    if (collapseQuadFace(aF[faceI][0]).type() > 0)
+                    {
+                        statistics_[7]++;
+                    }
+
+                    break;
+                }
+            }
+
+            continue;
+        }
+    }
+
+    // Clear out the list
+    thresholdSlivers_.clear();
+}
+
+
+// Identify the sliver type in 3D
+const changeMap dynamicTopoFvMesh::identifySliverType
+(
+    const label cIndex
+) const
+{
+    changeMap map;
+
+    // Ensure that this cell actually exists.
+    if (cells_[cIndex].empty())
+    {
+        return map;
+    }
+
+    label fourthPoint = -1;
+    scalar minDistance = GREAT;
+    face tFace(3), testFace(3), faceToCheck(3);
+    FixedList<edge, 2> edgeToCheck(edge(-1,-1));
+
+    const cell& cellToCheck = cells_[cIndex];
+
+    // Find the point-face pair with minimum perpendicular distance
+    forAll(cellToCheck, faceI)
+    {
+        label isolatedPoint = -1;
+        label nextFaceI = cellToCheck.fcIndex(faceI);
+
+        // Pick two faces from this cell.
+        const face& currFace = faces_[cellToCheck[faceI]];
+        const face& nextFace = faces_[cellToCheck[nextFaceI]];
+
+        // Get the fourth point
+        forAll(nextFace, pointI)
+        {
+            if
+            (
+                nextFace[pointI] != currFace[0]
+             && nextFace[pointI] != currFace[1]
+             && nextFace[pointI] != currFace[2]
+            )
+            {
+                isolatedPoint = nextFace[pointI];
+
+                // Configure a triangular face with correct orientation.
+                if (owner_[cellToCheck[faceI]] == cIndex)
+                {
+                    testFace[0] = currFace[2];
+                    testFace[1] = currFace[1];
+                    testFace[2] = currFace[0];
+                }
+                else
+                {
+                    testFace[0] = currFace[0];
+                    testFace[1] = currFace[1];
+                    testFace[2] = currFace[2];
+                }
+
+                break;
+            }
+        }
+
+        // Obtain the unit normal.
+        vector testNormal;
+        meshOps::faceNormal(testFace, points_, testNormal);
+
+        testNormal /= (mag(testNormal) + VSMALL);
+
+        // Project the isolated point onto the face.
+        vector p = points_[isolatedPoint] - points_[testFace[0]];
+        vector q = p - ((p & testNormal)*testNormal);
+
+        // Compute the distance
+        scalar distance = mag(p - q);
+
+        // Is it the least so far?
+        if (distance < minDistance)
+        {
+            // Use this point-face pair.
+            fourthPoint = isolatedPoint;
+            tFace = testFace;
+            minDistance = distance;
+        }
+    }
+
+    // Obtain the face-normal.
+    vector refArea;
+    meshOps::faceNormal(tFace, points_, refArea);
+
+    // Normalize it.
+    vector n = refArea/mag(refArea);
+
+    // Define edge-vectors.
+    vector r1 = points_[tFace[1]] - points_[tFace[0]];
+    vector r2 = points_[tFace[2]] - points_[tFace[1]];
+    vector r3 = points_[tFace[0]] - points_[tFace[2]];
+
+    // Project the fourth point onto the face.
+    vector r4 = points_[fourthPoint] - points_[tFace[0]];
+
+    r4 = r4 - ((r4 & n)*n);
+
+    // Define the two other vectors.
+    vector r5 = r4 - r1;
+    vector r6 = r5 - r2;
+
+    // Calculate three signed triangle areas, using tFace[0] as the origin.
+    scalar t1 = n & (0.5 * (r1 ^ r4));
+    scalar t2 = n & (0.5 * (r2 ^ r5));
+    scalar t3 = n & (0.5 * (r3 ^ r6));
+
+    // Determine sliver types based on are magnitudes.
+    if (t1 > 0 && t2 > 0 && t3 > 0)
+    {
+        // Region R0: Cap cell.
+        map.type() = 2;
+        map.apexPoint() = fourthPoint;
+
+        faceToCheck[0] = tFace[0];
+        faceToCheck[1] = tFace[1];
+        faceToCheck[2] = tFace[2];
+    }
+
+    if (t1 < 0 && t2 > 0 && t3 > 0)
+    {
+        // Region R1: Sliver cell.
+        map.type() = 1;
+
+        edgeToCheck[0][0] = tFace[2];
+        edgeToCheck[0][1] = fourthPoint;
+        edgeToCheck[1][0] = tFace[0];
+        edgeToCheck[1][1] = tFace[1];
+    }
+
+    if (t1 > 0 && t2 < 0 && t3 > 0)
+    {
+        // Region R2: Sliver cell.
+        map.type() = 1;
+
+        edgeToCheck[0][0] = tFace[0];
+        edgeToCheck[0][1] = fourthPoint;
+        edgeToCheck[1][0] = tFace[1];
+        edgeToCheck[1][1] = tFace[2];
+    }
+
+    if (t1 > 0 && t2 > 0 && t3 < 0)
+    {
+        // Region R3: Sliver cell.
+        map.type() = 1;
+
+        edgeToCheck[0][0] = tFace[1];
+        edgeToCheck[0][1] = fourthPoint;
+        edgeToCheck[1][0] = tFace[2];
+        edgeToCheck[1][1] = tFace[0];
+    }
+
+    if (t1 < 0 && t2 > 0 && t3 < 0)
+    {
+        // Region R4: Cap cell.
+        map.type() = 2;
+        map.apexPoint() = tFace[0];
+
+        faceToCheck[0] = tFace[1];
+        faceToCheck[1] = tFace[2];
+        faceToCheck[2] = fourthPoint;
+    }
+
+    if (t1 < 0 && t2 < 0 && t3 > 0)
+    {
+        // Region R5: Cap cell.
+        map.type() = 2;
+        map.apexPoint() = tFace[1];
+
+        faceToCheck[0] = tFace[2];
+        faceToCheck[1] = tFace[0];
+        faceToCheck[2] = fourthPoint;
+    }
+
+    if (t1 > 0 && t2 < 0 && t3 < 0)
+    {
+        // Region R6: Cap cell.
+        map.type() = 2;
+        map.apexPoint() = tFace[2];
+
+        faceToCheck[0] = tFace[0];
+        faceToCheck[1] = tFace[1];
+        faceToCheck[2] = fourthPoint;
+    }
+
+    // See if an over-ride to wedge/spade is necessary.
+    // Obtain a reference area magnitude.
+    scalar refMag = 0.1*(refArea & n);
+
+    if (mag(t1) < refMag)
+    {
+        if (mag(t3) < refMag)
+        {
+            // Wedge case: Too close to point [0]
+            map.type() = 4;
+
+            edgeToCheck[0][0] = tFace[0];
+            edgeToCheck[0][1] = fourthPoint;
+        }
+        else
+        if (mag(t2) < refMag)
+        {
+            // Wedge case: Too close to point [1]
+            map.type() = 4;
+
+            edgeToCheck[0][0] = tFace[1];
+            edgeToCheck[0][1] = fourthPoint;
+        }
+        else
+        if ((mag(t2) > refMag) && (mag(t3) > refMag))
+        {
+            // Spade case: Too close to edge vector r1
+            map.type() = 3;
+            map.apexPoint() = fourthPoint;
+
+            edgeToCheck[0][0] = tFace[0];
+            edgeToCheck[0][1] = tFace[1];
+        }
+    }
+
+    if (mag(t2) < refMag)
+    {
+        if (mag(t3) < refMag)
+        {
+            // Wedge case: Too close to point [2]
+            map.type() = 4;
+
+            edgeToCheck[0][0] = tFace[2];
+            edgeToCheck[0][1] = fourthPoint;
+        }
+        else
+        if ((mag(t1) > refMag) && (mag(t3) > refMag))
+        {
+            // Spade case: Too close to edge vector r2
+            map.type() = 3;
+            map.apexPoint() = fourthPoint;
+
+            edgeToCheck[0][0] = tFace[1];
+            edgeToCheck[0][1] = tFace[2];
+        }
+    }
+
+    if (mag(t3) < refMag)
+    {
+        if ((mag(t1) > refMag) && (mag(t2) > refMag))
+        {
+            // Spade case: Too close to edge vector r3
+            map.type() = 3;
+            map.apexPoint() = fourthPoint;
+
+            edgeToCheck[0][0] = tFace[2];
+            edgeToCheck[0][1] = tFace[0];
+        }
+    }
+
+    // Determine appropriate information for sliver exudation.
+    switch (map.type())
+    {
+        case 1:
+        {
+            FixedList<bool, 2> foundEdge(false);
+
+            // Search the cell-faces for first and second edges.
+            forAll(cellToCheck, faceI)
+            {
+                const labelList& fEdges = faceEdges_[cellToCheck[faceI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    const edge& thisEdge = edges_[fEdges[edgeI]];
+
+                    if (thisEdge == edgeToCheck[0])
+                    {
+                        map.firstEdge() = fEdges[edgeI];
+
+                        foundEdge[0] = true;
+                    }
+
+                    if (thisEdge == edgeToCheck[1])
+                    {
+                        map.secondEdge() = fEdges[edgeI];
+
+                        foundEdge[1] = true;
+                    }
+                }
+
+                if (foundEdge[0] && foundEdge[1])
+                {
+                    break;
+                }
+            }
+
+            break;
+        }
+
+        case 2:
+        {
+            // Search the cell-faces for opposing faces.
+            forAll(cellToCheck, faceI)
+            {
+                const face& thisFace = faces_[cellToCheck[faceI]];
+
+                if (triFace::compare(triFace(thisFace), triFace(faceToCheck)))
+                {
+                    map.opposingFace() = cellToCheck[faceI];
+
+                    break;
+                }
+            }
+
+            break;
+        }
+
+        case 3:
+        case 4:
+        {
+            bool foundEdge = false;
+
+            // Search the cell-faces for first edge.
+            forAll(cellToCheck, faceI)
+            {
+                const labelList& fEdges = faceEdges_[cellToCheck[faceI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    const edge& thisEdge = edges_[fEdges[edgeI]];
+
+                    if (thisEdge == edgeToCheck[0])
+                    {
+                        map.firstEdge() = fEdges[edgeI];
+
+                        foundEdge = true;
+                    }
+                }
+
+                if (foundEdge)
+                {
+                    break;
+                }
+            }
+
+            break;
+        }
+
+        default:
+        {
+            WarningIn
+            (
+                "void dynamicTopoFvMesh::identifySliverType"
+                "(const label cIndex) const"
+            )
+                << nl << "Could not identify sliver type for cell: "
+                << cIndex
+                << endl;
+        }
+    }
+
+    if (debug > 2)
+    {
+        Pout << "Cell: " << cIndex
+             << " Identified sliver type as: "
+             << map.type() << endl;
+    }
+
+    // Return the result.
+    return map;
+}
+
+
+// Remove sliver cells
+void dynamicTopoFvMesh::removeSlivers()
+{
+    if (!edgeRefinement_)
+    {
+        return;
+    }
+
+    // Check if a removeSlivers entry was found in the dictionary
+    if (dict_.subDict("dynamicTopoFvMesh").found("removeSlivers"))
+    {
+        Switch rs =
+        (
+            dict_.subDict("dynamicTopoFvMesh").lookup("removeSlivers")
+        );
+
+        if (!rs)
+        {
+            return;
+        }
+    }
+
+    // Invoke the 2D sliver removal routine
+    if (twoDMesh_)
+    {
+        remove2DSlivers();
+        return;
+    }
+
+    // Sort by sliver-quality.
+    labelList cIndices(thresholdSlivers_.toc());
+    SortableList<scalar> values(cIndices.size());
+
+    // Fill-in values to sort by...
+    forAll(cIndices, indexI)
+    {
+        values[indexI] = thresholdSlivers_[cIndices[indexI]];
+    }
+
+    // Explicitly sort by quality value.
+    values.sort();
+
+    const labelList& indices = values.indices();
+
+    if (debug && thresholdSlivers_.size())
+    {
+        Info << "Sliver list: " << endl;
+
+        forAll(indices, indexI)
+        {
+            label cIndex = cIndices[indices[indexI]];
+
+            Info << " Cell: " << cIndex
+                 << " Quality: " << thresholdSlivers_[cIndex]
+                 << endl;
+        }
+
+        if (debug > 1)
+        {
+            writeVTK("sliverCells", cIndices, 3);
+        }
+    }
+
+    forAll(indices, indexI)
+    {
+        // Fetch the cell index
+        label cIndex = cIndices[indices[indexI]];
+
+        // Identify the sliver type.
+        changeMap map = identifySliverType(cIndex);
+
+        if (debug)
+        {
+            InfoIn("void dynamicTopoFvMesh::removeSlivers()")
+                << nl << "Removing Cell: " << cIndex
+                << " of sliver type: " << map.type()
+                << " with quality: " << thresholdSlivers_[cIndex]
+                << endl;
+        }
+
+        bool success = false;
+
+        // Take action based on the type of sliver.
+        switch (map.type())
+        {
+            case -1:
+            {
+                // Sliver cell was removed by a prior operation.
+                // Nothing needs to be done.
+                break;
+            }
+
+            case 1:
+            {
+                // Sliver cell.
+                // Determine which edges need to be bisected.
+                label firstEdge = map.firstEdge();
+                label secondEdge = map.secondEdge();
+
+                // Force bisection on both edges.
+                changeMap firstMap  = bisectEdge(firstEdge, false, true);
+                changeMap secondMap = bisectEdge(secondEdge, false, true);
+
+                // Collapse the intermediate edge.
+                // Since we don't know which edge it is, search
+                // through recently added edges and compare.
+                edge edgeToCheck
+                (
+                    firstMap.addedPointList()[0][0],
+                    secondMap.addedPointList()[0][0]
+                );
+
+                bool foundCollapseEdge = false;
+
+                const List<FixedList<label,2> >& firstMapEdges =
+                (
+                    firstMap.addedEdgeList()
+                );
+
+                const List<FixedList<label,2> >& secondMapEdges =
+                (
+                    secondMap.addedEdgeList()
+                );
+
+                // Loop through the first list.
+                forAll(firstMapEdges, edgeI)
+                {
+                    const edge& thisEdge =
+                    (
+                        edges_[firstMapEdges[edgeI][0]]
+                    );
+
+                    if (thisEdge == edgeToCheck)
+                    {
+                        // Collapse this edge.
+                        if
+                        (
+                            collapseEdge
+                            (
+                                firstMapEdges[edgeI][0],
+                                -1,
+                                false,
+                                true
+                            ).type() > 0
+                        )
+                        {
+                            success = true;
+                        }
+
+                        foundCollapseEdge = true;
+                        break;
+                    }
+                }
+
+                // Loop through the second list.
+                if (!foundCollapseEdge)
+                {
+                    forAll(secondMapEdges, edgeI)
+                    {
+                        const edge& thisEdge =
+                        (
+                            edges_[secondMapEdges[edgeI][0]]
+                        );
+
+                        if (thisEdge == edgeToCheck)
+                        {
+                            // Collapse this edge.
+                            if
+                            (
+                                collapseEdge
+                                (
+                                    secondMapEdges[edgeI][0],
+                                    -1,
+                                    false,
+                                    true
+                                ).type() > 0
+                            )
+                            {
+                                success = true;
+                            }
+
+                            break;
+                        }
+                    }
+                }
+
+                break;
+            }
+
+            case 2:
+            {
+                // Cap cell.
+                label opposingFace = map.opposingFace();
+
+                // Force trisection of the opposing face.
+                changeMap faceMap =
+                (
+                    trisectFace(opposingFace, false, true)
+                );
+
+                // Collapse the intermediate edge.
+                // Since we don't know which edge it is, search
+                // through recently added edges and compare.
+                edge edgeToCheck
+                (
+                    map.apexPoint(),
+                    faceMap.addedPointList()[0][0]
+                );
+
+                const List<FixedList<label,2> >& faceMapEdges =
+                (
+                    faceMap.addedEdgeList()
+                );
+
+                forAll(faceMapEdges, edgeI)
+                {
+                    const edge& thisEdge = edges_[faceMapEdges[edgeI][0]];
+
+                    if (thisEdge == edgeToCheck)
+                    {
+                        // Collapse this edge.
+                        if
+                        (
+                            collapseEdge
+                            (
+                                faceMapEdges[edgeI][0],
+                                -1,
+                                false,
+                                true
+                            ).type() > 0
+                        )
+                        {
+                            success = true;
+                        }
+
+                        break;
+                    }
+                }
+
+                break;
+            }
+
+            case 3:
+            {
+                // Spade cell.
+
+                // Force bisection on the first edge.
+                changeMap firstMap =
+                (
+                    bisectEdge(map.firstEdge(), false, true)
+                );
+
+                // Collapse the intermediate edge.
+                // Since we don't know which edge it is, search
+                // through recently added edges and compare.
+                edge edgeToCheck
+                (
+                    map.apexPoint(),
+                    firstMap.addedPointList()[0][0]
+                );
+
+                const List<FixedList<label,2> >& firstMapEdges =
+                (
+                    firstMap.addedEdgeList()
+                );
+
+                // Loop through the first list.
+                forAll(firstMapEdges, edgeI)
+                {
+                    const edge& thisEdge = edges_[firstMapEdges[edgeI][0]];
+
+                    if (thisEdge == edgeToCheck)
+                    {
+                        // Collapse this edge.
+                        if
+                        (
+                            collapseEdge
+                            (
+                                firstMapEdges[edgeI][0],
+                                -1,
+                                false,
+                                true
+                            ).type() > 0
+                        )
+                        {
+                            success = true;
+                        }
+
+                        break;
+                    }
+                }
+
+                break;
+            }
+
+            case 4:
+            {
+                // Wedge cell.
+
+                // Collapse the first edge.
+                if
+                (
+                    collapseEdge
+                    (
+                        map.firstEdge(),
+                        -1,
+                        false,
+                        true
+                    ).type() > 0
+                )
+                {
+                    success = true;
+                }
+
+                break;
+            }
+
+            default:
+            {
+                WarningIn("void dynamicTopoFvMesh::removeSlivers()")
+                    << nl << "Could not identify sliver type for cell: "
+                    << cIndex
+                    << endl;
+            }
+        }
+
+        // Increment the count for successful sliver removal
+        if (success)
+        {
+            statistics_[7]++;
+        }
+    }
+
+    // Clear out the list
+    thresholdSlivers_.clear();
+}
+
+
+// MultiThreaded topology modifier
+void dynamicTopoFvMesh::threadedTopoModifier()
+{
+    // Remove sliver cells first.
+    removeSlivers();
+
+    // Coupled entities to avoid during normal modification
+    labelHashSet entities;
+
+    // Set the thread scheduling sequence
+    labelList topoSequence(threader_->getNumThreads());
+
+    // Linear sequence from 1 to nThreads
+    forAll(topoSequence, indexI)
+    {
+        topoSequence[indexI] = indexI + 1;
+    }
+
+    if (edgeRefinement_)
+    {
+        // Initialize stacks
+        initStacks(entities);
+
+        // Execute threads
+        if (threader_->multiThreaded())
+        {
+            executeThreads(topoSequence, handlerPtr_, &edgeRefinementEngine);
+        }
+
+        // Set the master thread to implement modifications
+        edgeRefinementEngine(&(handlerPtr_[0]));
+
+        if (debug)
+        {
+            Info << nl << "Edge Bisection/Collapse complete." << endl;
+        }
+    }
+
+    // Re-Initialize stacks
+    initStacks(entities);
+
+    // Execute threads
+    if (threader_->multiThreaded())
+    {
+        if (twoDMesh_)
+        {
+            executeThreads(topoSequence, handlerPtr_, &swap2DEdges);
+        }
+        else
+        {
+            executeThreads(topoSequence, handlerPtr_, &swap3DEdges);
+        }
+    }
+
+    // Set the master thread to implement modifications
+    if (twoDMesh_)
+    {
+        swap2DEdges(&(handlerPtr_[0]));
+    }
+    else
+    {
+        swap3DEdges(&(handlerPtr_[0]));
+    }
+
+    if (debug)
+    {
+        Info << nl << "Edge Swapping complete." << endl;
+    }
+}
+
+
+// Reset the mesh and generate mapping information
+//  - Return true if topology changes were made.
+//  - Return false otherwise (motion only)
+bool dynamicTopoFvMesh::resetMesh()
+{
+    // Reduce across processors.
+    reduce(topoChangeFlag_, orOp<bool>());
+
+    if (topoChangeFlag_)
+    {
+        // Write out statistics
+        Info << " Bisections :: Total: " << status(3)
+             << ", Surface: " << status(5) << endl;
+        Info << " Collapses  :: Total: " << status(4)
+             << ", Surface: " << status(6) << endl;
+        Info << " Swaps      :: Total: " << status(1)
+             << ", Surface: " << status(2) << endl;
+
+        if (status(7))
+        {
+            Info << " Slivers    :: " << status(7) << endl;
+        }
+
+        // Set sizes for mapping
+        faceWeights_.setSize(facesFromFaces_.size(), scalarField(0));
+        faceCentres_.setSize(facesFromFaces_.size(), vectorField(0));
+        cellWeights_.setSize(cellsFromCells_.size(), scalarField(0));
+        cellCentres_.setSize(cellsFromCells_.size(), vectorField(0));
+
+        // Fetch the match tolerance for mapping
+        scalar matchTol = Foam::debug::tolerances("meshOpsMatchTol", 1e-4);
+
+        // Determine if mapping is to be skipped
+        // Optionally skip mapping for remeshing-only / pre-processing
+        const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+        bool skipMapping = false;
+
+        if (meshSubDict.found("skipMapping") || mandatory_)
+        {
+            skipMapping = readBool(meshSubDict.lookup("skipMapping"));
+        }
+
+        clockTime mappingTimer;
+
+        // Compute mapping weights for modified entities
+        threadedMapping(matchTol, skipMapping);
+
+        // Print out stats
+        Info << " Mapping time: " << mappingTimer.elapsedTime()
+             << " s" << endl;
+
+        // Obtain references to zones, if any
+        pointZoneMesh& pointZones = polyMesh::pointZones();
+        faceZoneMesh& faceZones = polyMesh::faceZones();
+        cellZoneMesh& cellZones = polyMesh::cellZones();
+
+        // Allocate temporary lists for mesh-reset
+        pointField points(nPoints_);
+        pointField preMotionPoints(nPoints_);
+        edgeList edges(nEdges_);
+        faceList faces(nFaces_);
+        labelList owner(nFaces_);
+        labelList neighbour(nInternalFaces_);
+        labelListList faceEdges(nFaces_);
+        labelListList edgeFaces(nEdges_);
+        labelList oldPatchStarts(oldPatchStarts_);
+        labelList oldPatchNMeshPoints(oldPatchNMeshPoints_);
+        labelListList pointZoneMap(pointZones.size());
+        labelListList faceZonePointMap(faceZones.size());
+        labelListList faceZoneFaceMap(faceZones.size());
+        labelListList cellZoneMap(cellZones.size());
+
+        // Obtain faceZone point maps before reordering
+        List<Map<label> > oldFaceZonePointMaps(faceZones.size());
+
+        forAll(faceZones, fzI)
+        {
+            oldFaceZonePointMaps[fzI] = faceZones[fzI]().meshPointMap();
+        }
+
+        clockTime reOrderingTimer;
+
+        // Reorder the mesh and obtain current topological information
+        reOrderMesh
+        (
+            points,
+            preMotionPoints,
+            edges,
+            faces,
+            owner,
+            neighbour,
+            faceEdges,
+            edgeFaces,
+            pointZoneMap,
+            faceZoneFaceMap,
+            cellZoneMap
+        );
+
+        // Print out stats
+        Info << " Reordering time: " << reOrderingTimer.elapsedTime()
+             << " s" << endl;
+
+        // Obtain the patch-point maps before resetting the mesh
+        List<Map<label> > oldPatchPointMaps(boundaryMesh().size());
+
+        forAll(oldPatchPointMaps, patchI)
+        {
+            oldPatchPointMaps[patchI] = boundaryMesh()[patchI].meshPointMap();
+        }
+
+        topoMapper& fieldMapper = mapper_();
+
+        // Set information for the mapping stage, prior to mesh reset
+        fieldMapper.storeMeshInformation();
+
+        // Set weighting information.
+        // This takes over the weight data.
+        fieldMapper.setFaceWeights
+        (
+            xferMove(faceWeights_),
+            xferMove(faceCentres_)
+        );
+
+        fieldMapper.setCellWeights
+        (
+            xferMove(cellWeights_),
+            xferMove(cellCentres_)
+        );
+
+        // Reset the mesh with pre-motion points
+        polyMesh::resetPrimitives
+        (
+            xferCopy(preMotionPoints),
+            xferMove(faces),
+            xferMove(owner),
+            xferMove(neighbour),
+            patchSizes_,
+            patchStarts_
+        );
+
+        // Check the dictionary to determine whether
+        // edge-connectivity is to be stored on disk.
+        // This usually benefits restart-time for large
+        // cases, at the expense of disk-space.
+        bool storePrimitives = false;
+
+        if (meshSubDict.found("storeEdgePrimitives") || mandatory_)
+        {
+            storePrimitives =
+            (
+                readBool(meshSubDict.lookup("storeEdgePrimitives"))
+            );
+        }
+
+        // Reset the edge mesh
+        eMeshPtr_->resetPrimitives
+        (
+            edges,
+            faceEdges,
+            edgeFaces,
+            edgePatchSizes_,
+            edgePatchStarts_,
+            true,
+            (time().outputTime() && storePrimitives)
+        );
+
+        // Generate mapping for points on boundary patches
+        labelListList patchPointMap(boundaryMesh().size());
+
+        for (label i = 0; i < boundaryMesh().size(); i++)
+        {
+            // Obtain new patch mesh points after reset.
+            const labelList& meshPointLabels = boundaryMesh()[i].meshPoints();
+
+            patchNMeshPoints_[i] = meshPointLabels.size();
+
+            patchPointMap[i].setSize(meshPointLabels.size(), -1);
+
+            forAll(meshPointLabels, pointI)
+            {
+                label oldIndex = pointMap_[meshPointLabels[pointI]];
+
+                // Check if the point existed before...
+                if (oldIndex > -1)
+                {
+                    // Look for the old position on this patch.
+                    Map<label>::const_iterator oIter =
+                    (
+                        oldPatchPointMaps[i].find(oldIndex)
+                    );
+
+                    // Add an entry if the point was found
+                    if (oIter != oldPatchPointMaps[i].end())
+                    {
+                        patchPointMap[i][pointI] = oIter();
+                    }
+                }
+            }
+        }
+
+        // Generate mapping for faceZone points
+        forAll(faceZones, fzI)
+        {
+            // Obtain new face zone mesh points after reset.
+            const labelList& meshPointLabels = faceZones[fzI]().meshPoints();
+
+            faceZonePointMap[fzI].setSize(meshPointLabels.size(), -1);
+
+            forAll(meshPointLabels, pointI)
+            {
+                label oldIndex = pointMap_[meshPointLabels[pointI]];
+
+                // Check if the point existed before...
+                if (oldIndex > -1)
+                {
+                    // Look for the old position on this patch.
+                    Map<label>::const_iterator oIter =
+                    (
+                        oldFaceZonePointMaps[fzI].find(oldIndex)
+                    );
+
+                    // Add an entry if the point was found
+                    if (oIter != oldFaceZonePointMaps[fzI].end())
+                    {
+                        faceZonePointMap[fzI][pointI] = oIter();
+                    }
+                }
+            }
+        }
+
+        // Generate new mesh mapping information
+        mapPolyMesh mpm
+        (
+            (*this),
+            nOldPoints_,
+            nOldFaces_,
+            nOldCells_,
+            pointMap_,
+            pointsFromPoints_,
+            faceMap_,
+            facesFromPoints_,
+            facesFromEdges_,
+            facesFromFaces_,
+            cellMap_,
+            cellsFromPoints_,
+            cellsFromEdges_,
+            cellsFromFaces_,
+            cellsFromCells_,
+            reversePointMap_,
+            reverseFaceMap_,
+            reverseCellMap_,
+            flipFaces_,
+            patchPointMap,
+            pointZoneMap,
+            faceZonePointMap,
+            faceZoneFaceMap,
+            cellZoneMap,
+            preMotionPoints,
+            oldPatchStarts,
+            oldPatchNMeshPoints,
+            true
+        );
+
+        // Update the underlying mesh, and map all related fields
+        updateMesh(mpm);
+
+        // Perform a dummy movePoints to force V0 creation, if necessary
+        movePoints(mpm.preMotionPoints());
+
+        // Reset old-volumes
+        resetMotion();
+        setV0();
+
+        // Correct volume fluxes on the old mesh
+        fieldMapper.correctFluxes();
+
+        // Clear mapper after use
+        fieldMapper.clear();
+
+        // Now move mesh to new points and
+        // compute correct mesh-fluxes.
+        movePoints(points);
+
+        // Update the mesh-motion solver
+        if (motionSolver_.valid())
+        {
+            motionSolver_->updateMesh(mpm);
+        }
+
+        // Clear unwanted member data
+        addedFacePatches_.clear();
+        addedEdgePatches_.clear();
+        addedPointZones_.clear();
+        addedFaceZones_.clear();
+        addedCellZones_.clear();
+        faceParents_.clear();
+        cellParents_.clear();
+
+        // Clear the deleted entity map
+        deletedPoints_.clear();
+        deletedEdges_.clear();
+        deletedFaces_.clear();
+        deletedCells_.clear();
+
+        // Clear flipFaces / modPoints
+        flipFaces_.clear();
+        modPoints_.clear();
+
+        // Set new sizes for the reverse maps
+        reversePointMap_.setSize(nPoints_, -7);
+        reverseEdgeMap_.setSize(nEdges_, -7);
+        reverseFaceMap_.setSize(nFaces_, -7);
+        reverseCellMap_.setSize(nCells_, -7);
+
+        // Update "old" information
+        nOldPoints_ = nPoints_;
+        nOldEdges_ = nEdges_;
+        nOldFaces_ = nFaces_;
+        nOldCells_ = nCells_;
+        nOldInternalFaces_ = nInternalFaces_;
+        nOldInternalEdges_ = nInternalEdges_;
+
+        for (label i = 0; i < boundaryMesh().size(); i++)
+        {
+            oldPatchSizes_[i] = patchSizes_[i];
+            oldPatchStarts_[i] = patchStarts_[i];
+            oldEdgePatchSizes_[i] = edgePatchSizes_[i];
+            oldEdgePatchStarts_[i] = edgePatchStarts_[i];
+            oldPatchNMeshPoints_[i] = patchNMeshPoints_[i];
+        }
+
+        // Basic checks for mesh-validity
+        if (debug > 2)
+        {
+            checkMesh(true);
+        }
+
+        // Reset statistics
+        statistics_ = 0;
+    }
+    else
+    {
+        // No topology changes were made.
+        // Only execute mesh-motion.
+        if (motionSolver_.valid())
+        {
+            movePoints(motionSolver_->curPoints());
+        }
+    }
+
+    // Obtain mesh stats after topo-changes
+    meshQuality(true);
+
+    // Dump length-scale to disk, if requested.
+    calculateLengthScale(true);
+
+    // Reset and return flag
+    if (topoChangeFlag_)
+    {
+        topoChangeFlag_ = false;
+        return true;
+    }
+
+    // No changes were made.
+    return false;
+}
+
+
+// Map all fields in time using a customized mapper
+void dynamicTopoFvMesh::mapFields(const mapPolyMesh& meshMap) const
+{
+    if (debug)
+    {
+        Info << "void dynamicTopoFvMesh::mapFields(const mapPolyMesh&): "
+             << "Mapping fv fields."
+             << endl;
+    }
+
+    const topoMapper& fieldMapper = mapper_();
+
+    // Set the mapPolyMesh object in the mapper
+    fieldMapper.setMapper(meshMap);
+
+    // Conservatively map scalar/vector volFields
+    fieldMapper.conservativeMapVolFields<scalar>();
+    fieldMapper.conservativeMapVolFields<vector>();
+
+    // Map all the volFields in the objectRegistry
+    MapGeometricFields<sphericalTensor,fvPatchField,topoMapper,volMesh>
+        (fieldMapper);
+    MapGeometricFields<symmTensor,fvPatchField,topoMapper,volMesh>
+        (fieldMapper);
+    MapGeometricFields<tensor,fvPatchField,topoMapper,volMesh>
+        (fieldMapper);
+
+    // Conservatively map scalar/vector surfaceFields
+    fieldMapper.conservativeMapSurfaceFields<scalar>();
+    fieldMapper.conservativeMapSurfaceFields<vector>();
+
+    // Map all the surfaceFields in the objectRegistry
+    MapGeometricFields<sphericalTensor,fvsPatchField,topoMapper,surfaceMesh>
+        (fieldMapper);
+    MapGeometricFields<symmTensor,fvsPatchField,topoMapper,surfaceMesh>
+        (fieldMapper);
+    MapGeometricFields<tensor,fvsPatchField,topoMapper,surfaceMesh>
+        (fieldMapper);
+}
+
+
+// Update the mesh for motion / topology changes.
+//  - Return true if topology changes have occurred
+bool dynamicTopoFvMesh::update()
+{
+    // Re-read options, in case they have been modified at run-time
+    readOptionalParameters(true);
+
+    // Set old point positions
+    oldPoints_ = polyMesh::points();
+
+    // Invoke mesh-motion solver and store new points
+    if (motionSolver_.valid())
+    {
+        points_ = motionSolver_->newPoints()();
+    }
+
+    // Obtain mesh stats before topo-changes
+    bool noSlivers = meshQuality(true);
+
+    // Return if the interval is invalid,
+    // not at re-mesh interval, or slivers are absent.
+    // Handy while using only mesh-motion.
+    if (interval_ < 0 || ((time().timeIndex() % interval_ != 0) && noSlivers))
+    {
+        return resetMesh();
+    }
+
+    // Calculate the edge length-scale for the mesh
+    calculateLengthScale();
+
+    // Track mesh topology modification time
+    clockTime topoTimer;
+
+    // Invoke the threaded topoModifier
+    threadedTopoModifier();
+
+    Info << " Topo modifier time: "
+         << topoTimer.elapsedTime() << " s"
+         << endl;
+
+    // Apply all topology changes (if any) and reset mesh.
+    return resetMesh();
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void dynamicTopoFvMesh::operator=(const dynamicTopoFvMesh& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "dynamicTopoFvMesh::operator=(const dynamicTopoFvMesh&)"
+        )
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
new file mode 100644
index 000000000..3782a33c3
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H
@@ -0,0 +1,845 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    An implementation of dynamic changes to mesh-topology
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    dynamicTopoFvMesh.C
+    dynamicTopoFvMeshI.H
+    dynamicTopoFvMeshCheck.C
+    dynamicTopoFvMeshReOrder.C
+    dynamicTopoFvMeshMapping.C
+    edgeBisect.C
+    edgeCollapse.C
+    edgeSwap.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicTopoFvMesh_H
+#define dynamicTopoFvMesh_H
+
+#include "Switch.H"
+#include "tetMetric.H"
+#include "threadHandler.H"
+#include "dynamicFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class eMesh;
+class Stack;
+class changeMap;
+class objectMap;
+class topoMapper;
+class motionSolver;
+class lengthScaleEstimator;
+
+/*---------------------------------------------------------------------------*\
+                      Class dynamicTopoFvMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class dynamicTopoFvMesh
+:
+    public dynamicFvMesh
+{
+    // Private data
+
+        //- Topology change flag
+        bool topoChangeFlag_;
+
+        //- Dynamic mesh dictionary
+        IOdictionary dict_;
+
+        //- Should all options be mandatorily specified?
+        //  Handy for first-time use.
+        Switch mandatory_;
+
+        //- Mesh characteristics [2D/3D]
+        Switch twoDMesh_;
+
+        //- Edge refinement switch
+        Switch edgeRefinement_;
+
+        //- Switch for cell-bandwidth reduction
+        Switch bandWidthReduction_;
+
+        //- Specify the re-meshing interval
+        label interval_;
+
+        //- Edge-mesh
+        autoPtr<eMesh> eMeshPtr_;
+
+        //- Field mapper
+        autoPtr<topoMapper> mapper_;
+
+        //- Mesh motion solver
+        autoPtr<motionSolver> motionSolver_;
+
+        //- Length scale estimator
+        autoPtr<lengthScaleEstimator> lengthEstimator_;
+
+        //- Lists that dynamically resize during topo-changes
+        //   - Since resizes happen infrequently,
+        //     scale up by 10% to save memory.
+        //   - Current C++ standard doesn't
+        //     support template typedefs,
+        //     so this is a work-around
+        template <class T>
+        class resizableList
+        {
+        public:
+            typedef DynamicList<T, 0, 11, 10> Type;
+        };
+
+        resizableList<point>::Type oldPoints_, points_;
+        resizableList<face>::Type faces_;
+        resizableList<label>::Type owner_, neighbour_;
+        resizableList<cell>::Type cells_;
+        resizableList<edge>::Type edges_;
+        resizableList<labelList>::Type pointEdges_, edgePoints_;
+        resizableList<labelList>::Type edgeFaces_, faceEdges_;
+        resizableList<scalar>::Type lengthScale_;
+
+        //- Size information
+        labelList oldPatchSizes_, patchSizes_;
+        labelList oldPatchStarts_, patchStarts_;
+        labelList oldEdgePatchSizes_, edgePatchSizes_;
+        labelList oldEdgePatchStarts_, edgePatchStarts_;
+        labelList oldPatchNMeshPoints_, patchNMeshPoints_;
+        label nOldPoints_, nPoints_;
+        label nOldEdges_, nEdges_;
+        label nOldFaces_, nFaces_;
+        label nOldCells_, nCells_;
+        label nOldInternalFaces_, nInternalFaces_;
+        label nOldInternalEdges_, nInternalEdges_;
+
+        //- Maps [Old-to-New]
+        labelList reversePointMap_;
+        labelList reverseEdgeMap_;
+        labelList reverseFaceMap_;
+        labelList reverseCellMap_;
+
+        //- Maps [New-to-Old]
+        labelList pointMap_;
+        labelList edgeMap_;
+        labelList faceMap_;
+        labelList cellMap_;
+
+        //- Maps for the renumbering of added entities
+        Map<label> addedPointRenumbering_;
+        Map<label> addedEdgeRenumbering_;
+        Map<label> addedFaceRenumbering_;
+        Map<label> addedCellRenumbering_;
+        Map<label> addedFacePatches_;
+        Map<label> addedEdgePatches_;
+        Map<label> addedPointZones_;
+        Map<label> addedFaceZones_;
+        Map<label> addedCellZones_;
+
+        // Information for field-mapping
+        Map<labelList> faceParents_;
+        List<scalarField> faceWeights_;
+        List<vectorField> faceCentres_;
+        Map<labelList> cellParents_;
+        List<scalarField> cellWeights_;
+        List<vectorField> cellCentres_;
+
+        // Information for mapPolyMesh
+        List<objectMap> pointsFromPoints_;
+        List<objectMap> facesFromPoints_;
+        List<objectMap> facesFromEdges_;
+        List<objectMap> facesFromFaces_;
+        List<objectMap> cellsFromPoints_;
+        List<objectMap> cellsFromEdges_;
+        List<objectMap> cellsFromFaces_;
+        List<objectMap> cellsFromCells_;
+
+        //- Maps to keep track of entities deleted after addition
+        labelHashSet deletedPoints_;
+        labelHashSet deletedEdges_;
+        labelHashSet deletedFaces_;
+        labelHashSet deletedCells_;
+
+        //- List of flipped faces / modified old-points
+        labelHashSet flipFaces_;
+        Map<labelList> modPoints_;
+
+        //- Run-time statistics
+        label maxModifications_;
+        FixedList<label, 8> statistics_;
+
+        //- Sliver exudation
+        scalar sliverThreshold_;
+        Map<scalar> thresholdSlivers_;
+
+        //- Specific to proximity-based refinement
+        List<labelPair> slicePairs_;
+
+        //- 3D Mesh Flipping data
+        label maxTetsPerEdge_;
+        scalar swapDeviation_;
+        Switch allowTableResize_;
+        labelList noSwapPatchIDs_;
+
+        //- Stack-list of entities to be checked for topo-changes.
+        List<Stack> entityStack_;
+
+        //- Support for multithreading
+        autoPtr<IOmultiThreader> threader_;
+
+        // Pointer-list of thread-handlers
+        typedef threadHandler<dynamicTopoFvMesh> meshHandler;
+
+        PtrList<meshHandler> handlerPtr_;
+
+        // Entity mutexes used for synchronization
+        // in multi-threaded reOrdering
+        FixedList<Mutex, 4> entityMutex_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        dynamicTopoFvMesh(const dynamicTopoFvMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const dynamicTopoFvMesh&);
+
+        // Perform a Delaunay test on an internal face
+        bool testDelaunay(const label fIndex) const;
+
+        //- Quality metric for tetrahedra in 3D
+        tetMetric::tetMetricReturnType tetMetric_;
+
+        // Compute mapping weights for modified entities
+        void computeMapping
+        (
+            const scalar matchTol,
+            const bool skipMapping,
+            const label faceStart,
+            const label faceSize,
+            const label cellStart,
+            const label cellSize
+        );
+
+        // Static equivalent for multiThreading
+        static void computeMappingThread(void *argument);
+
+        // Routine to invoke threaded mapping
+        void threadedMapping(scalar matchTol, bool skipMapping);
+
+        // Initialize mesh edges and related connectivity lists
+        void initEdges();
+
+        // Load the mesh-quality metric from the library
+        void loadMetric();
+
+        // Load the mesh-motion solver
+        void loadMotionSolver();
+
+        // Load the field mapper
+        void loadFieldMapper();
+
+        // Load the length scale estimator
+        void loadLengthScaleEstimator();
+
+        // Initialize the threading environment
+        void initializeThreadingEnvironment(const label specThreads = -1);
+
+        // Return a non-const reference to the lengthScaleEstimator
+        inline lengthScaleEstimator& lengthEstimator();
+
+        // Return a const reference to the lengthScaleEstimator
+        inline const lengthScaleEstimator& lengthEstimator() const;
+
+        // Return a const reference to the multiThreader
+        inline const multiThreader& threader() const;
+
+        // Return a reference to the entity mutexes
+        inline const Mutex& entityMutex(const label entity) const;
+
+        // Return the edge index for a provided edge
+        inline label getEdgeIndex(const edge& edgeToCheck) const;
+
+        // Given a boundary face, pick out a boundary edge that
+        // contains a triangular face.
+        inline label getTriBoundaryEdge(const label fIndex) const;
+
+        // Return length-scale at an face-location in the mesh [2D]
+        inline scalar faceLengthScale(const label fIndex) const;
+
+        // Return length-scale at an edge-location in the mesh [3D]
+        inline scalar edgeLengthScale(const label eIndex) const;
+
+        // Check for bisection
+        inline bool checkBisection(const label index) const;
+
+        // Check for collapse
+        inline bool checkCollapse(const label index) const;
+
+        // MultiThreaded topology modifier
+        void threadedTopoModifier();
+
+        // 2D Edge-swapping engine
+        static void swap2DEdges(void *argument);
+
+        // 3D Edge-swapping engine
+        static void swap3DEdges(void *argument);
+
+        // Edge refinement engine
+        static void edgeRefinementEngine(void *argument);
+
+        // Return the entity stack for a particular thread
+        inline Stack& stack(const label threadID);
+
+        // Return the integer ID for a given thread
+        inline label self() const;
+
+        // Initialize stacks
+        inline void initStacks(const labelHashSet& entities);
+
+        // Method to determine the boundary patch index for a given face
+        inline label whichPatch(const label index) const;
+
+        // 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;
+
+        // Method for the swapping of a quad-face in 2D
+        const changeMap
+        swapQuadFace
+        (
+            const label fIndex
+        );
+
+        // Method for the bisection of a quad-face in 2D
+        const changeMap
+        bisectQuadFace
+        (
+            const label fIndex,
+            const changeMap& masterMap,
+            bool checkOnly = false,
+            bool forceOp = false
+        );
+
+        // Method for the collapse of a quad-face in 2D
+        const changeMap
+        collapseQuadFace
+        (
+            const label fIndex,
+            label overRideCase = -1,
+            bool checkOnly = false,
+            bool forceOp = false
+        );
+
+        // Method for the swapping of an edge in 3D
+        void swapEdge
+        (
+            const label eIndex,
+            bool forceOp = false
+        );
+
+        // Method for the bisection of an edge in 3D
+        const changeMap
+        bisectEdge
+        (
+            const label eIndex,
+            bool checkOnly = false,
+            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
+        (
+            const label eIndex,
+            label overRideCase = -1,
+            bool checkOnly = false,
+            bool forceOp = false
+        );
+
+        // Utility method to check for invalid face-bisection.
+        bool checkBisection
+        (
+            const label fIndex,
+            const label bFaceIndex,
+            bool forceOp = false
+        ) const;
+
+        // Utility method to check for invalid face-collapse.
+        bool checkCollapse
+        (
+            const labelList& triFaces,
+            const FixedList<label,2>& c0BdyIndex,
+            const FixedList<label,2>& c1BdyIndex,
+            const FixedList<label,2>& pointIndex,
+            const FixedList<point,2>& newPoint,
+            const FixedList<point,2>& oldPoint,
+            scalar& collapseQuality,
+            const bool checkNeighbour,
+            bool forceOp = false
+        ) const;
+
+        // Utility method to check for invalid edge-collapse.
+        bool checkCollapse
+        (
+            const point& newPoint,
+            const point& oldPoint,
+            const label pointIndex,
+            const label cellIndex,
+            labelHashSet& cellsChecked,
+            scalar& collapseQuality,
+            bool forceOp = false
+        ) const;
+
+        // Remove 2D sliver cells from the mesh
+        void remove2DSlivers();
+
+        // Identify the sliver type in 3D
+        const changeMap identifySliverType(const label cIndex) const;
+
+        // Remove sliver cells
+        void removeSlivers();
+
+        // Insert the specified cell to the mesh
+        label insertCell
+        (
+            const cell& newCell,
+            const scalar lengthScale,
+            const label zoneID = -1
+        );
+
+        // Set fill-in mapping information for a particular cell
+        void setCellMapping
+        (
+            const label cIndex,
+            const labelList& mapCells,
+            bool addEntry = true
+        );
+
+        // Set fill-in mapping information for a particular face
+        void setFaceMapping
+        (
+            const label fIndex,
+            const labelList& mapFaces = labelList(0)
+        );
+
+        // Remove the specified cells from the mesh
+        const changeMap
+        removeCells
+        (
+            const labelList& cList,
+            const label patch
+        );
+
+        // Remove the specified cell from the mesh
+        void removeCell
+        (
+            const label cIndex
+        );
+
+        // Insert the specified face to the mesh
+        label insertFace
+        (
+            const label patch,
+            const face& newFace,
+            const label newOwner,
+            const label newNeighbour,
+            const label zoneID = -1
+        );
+
+        // Remove the specified face from the mesh
+        void removeFace
+        (
+            const label fIndex
+        );
+
+        // Split a set of internal faces into boundary faces,
+        // and add them to the specified patch.
+        void splitInternalFaces
+        (
+            const label patchIndex,
+            const labelList& internalFaces,
+            const Map<bool>& cellColors
+        );
+
+        // Insert the specified edge to the mesh
+        label insertEdge
+        (
+            const label patch,
+            const edge& newEdge,
+            const labelList& edgeFaces,
+            const labelList& edgePoints = labelList::null()
+        );
+
+        // Remove the specified edge from the mesh
+        void removeEdge
+        (
+            const label eIndex
+        );
+
+        // Insert the specified point to the mesh
+        label insertPoint
+        (
+            const point& newPoint,
+            const point& oldPoint,
+            const labelList& mapPoints,
+            const label zoneID = -1
+        );
+
+        // Remove the specified point from the mesh
+        void removePoint
+        (
+            const label pIndex
+        );
+
+        // Utility method to build edgePoints for an edge [3D]
+        void buildEdgePoints
+        (
+            const label eIndex,
+            const label checkIndex = 0
+        );
+
+        // Utility to check whether points of an edge lie on a boundary
+        const FixedList<bool,2> checkEdgeBoundary(const label eIndex) const;
+
+        // Set a particular face index as flipped.
+        inline void setFlip(const label fIndex);
+
+        // Utility method to compute the minimum quality of a vertex hull
+        scalar computeMinQuality(const label eIndex) const;
+
+        // Utility method to compute the quality of a vertex hull
+        // 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(const label eIndex) const;
+
+        // Allocate dynamic programming tables
+        void initTables
+        (
+            labelList& m,
+            PtrList<scalarListList>& Q,
+            PtrList<labelListList>& K,
+            PtrList<labelListList>& triangulations,
+            const label checkIndex = -1
+        ) const;
+
+        // Check triangulation quality for an edge index
+        bool checkQuality
+        (
+            const label eIndex,
+            const labelList& m,
+            const PtrList<scalarListList>& Q,
+            const scalar minQuality,
+            const label checkIndex = 0
+        ) const;
+
+        // Utility method to fill the dynamic programming tables
+        bool fillTables
+        (
+            const label eIndex,
+            const scalar minQuality,
+            labelList& m,
+            PtrList<scalarListList>& Q,
+            PtrList<labelListList>& K,
+            PtrList<labelListList>& triangulations,
+            const label checkIndex = 0
+        ) const;
+
+        // Print out tables for debugging
+        void printTables
+        (
+            const labelList& m,
+            const PtrList<scalarListList>& Q,
+            const PtrList<labelListList>& K,
+            const label checkIndex = 0
+        ) const;
+
+        // Remove the edge according to the swap sequence
+        const changeMap
+        removeEdgeFlips
+        (
+            const label eIndex,
+            const scalar minQuality,
+            const PtrList<labelListList>& K,
+            PtrList<labelListList>& triangulations,
+            const label checkIndex = 0
+        );
+
+        // Extract triangulations from the programming table
+        void extractTriangulation
+        (
+            const label i,
+            const label j,
+            const labelListList& K,
+            label& numTriangulations,
+            labelListList& triangulations
+        ) const;
+
+        // Identify the 3-2 swap from the triangulation sequence
+        label identify32Swap
+        (
+            const label eIndex,
+            const labelList& hullVertices,
+            const labelListList& triangulations
+        ) const;
+
+        // Check old-volumes for the configuration.
+        bool checkTriangulationVolumes
+        (
+            const label eIndex,
+            const labelList& hullVertices,
+            const labelListList& triangulations
+        ) const;
+
+        // Routine to check whether the triangulation at the
+        // index lies on the boundary of the vertex ring.
+        bool boundaryTriangulation
+        (
+            const label index,
+            label& isolatedVertex,
+            labelListList& triangulations
+        ) const;
+
+        // Routine to perform 2-3 swaps
+        const changeMap
+        swap23
+        (
+            const label isolatedVertex,
+            const label eIndex,
+            const label triangulationIndex,
+            const label numTriangulations,
+            const labelListList& triangulations,
+            const labelList& hullVertices,
+            const labelList& hullFaces,
+            const labelList& hullCells
+        );
+
+        // Routine to perform 3-2 or 2-2 swaps
+        const changeMap
+        swap32
+        (
+            const label eIndex,
+            const label triangulationIndex,
+            const label numTriangulations,
+            const labelListList& triangulations,
+            const labelList& hullVertices,
+            const labelList& hullFaces,
+            const labelList& hullCells
+        );
+
+        // Reorder points after a topology change
+        void reOrderPoints
+        (
+            pointField& points,
+            pointField& preMotionPoints,
+            labelListList& pointZoneMap,
+            bool threaded = false
+        );
+
+        // Static equivalent for multi-threading
+        static void reOrderPointsThread(void *argument);
+
+        // Reorder edges after a topology change
+        void reOrderEdges
+        (
+            edgeList& edges,
+            labelListList& edgeFaces,
+            labelListList& faceEdges,
+            bool threaded = false
+        );
+
+        // Static equivalent for multi-threading
+        static void reOrderEdgesThread(void *argument);
+
+        // Reorder faces in upper-triangular order after a topology change
+        void reOrderFaces
+        (
+            faceList& faces,
+            labelList& owner,
+            labelList& neighbour,
+            labelListList& faceEdges,
+            labelListList& faceZoneFaceMap,
+            bool threaded = false
+        );
+
+        // Static equivalent for multi-threading
+        static void reOrderFacesThread(void *argument);
+
+        // Reorder & renumber cells with bandwidth
+        // reduction after a topology change
+        void reOrderCells
+        (
+            labelListList& cellZoneMap,
+            bool threaded = false
+        );
+
+        // Static equivalent for multi-threading
+        static void reOrderCellsThread(void *argument);
+
+        // Reorder the mesh in upper-triangular order,
+        // and generate mapping information
+        void reOrderMesh
+        (
+            pointField& points,
+            pointField& preMotionPoints,
+            edgeList& edges,
+            faceList& faces,
+            labelList& owner,
+            labelList& neighbour,
+            labelListList& faceEdges,
+            labelListList& edgeFaces,
+            labelListList& pointZoneMap,
+            labelListList& faceZoneFaceMap,
+            labelListList& cellZoneMap
+        );
+
+        // Invoke reOrdering with multiple threads
+        void threadedMeshReOrdering
+        (
+            pointField& points,
+            pointField& preMotionPoints,
+            edgeList& edges,
+            faceList& faces,
+            labelList& owner,
+            labelList& neighbour,
+            labelListList& faceEdges,
+            labelListList& edgeFaces,
+            labelListList& pointZoneMap,
+            labelListList& faceZoneFaceMap,
+            labelListList& cellZoneMap
+        );
+
+        // Reset the mesh and generate mapping information
+        bool resetMesh();
+
+        // Output an entity as a VTK file
+        void writeVTK
+        (
+            const word& name,
+            const label entity,
+            const label primitiveType = 3,
+            const bool useOldConnectivity = false,
+            const bool useOldPoints = false
+        ) const;
+
+        // Output a list of entities as a VTK file
+        void writeVTK
+        (
+            const word& name,
+            const labelList& cList,
+            const label primitiveType = 3,
+            const bool useOldConnectivity = false,
+            const bool useOldPoints = false
+        ) const;
+
+        // Return the status report interval
+        scalar reportInterval() const;
+
+        // Check the state of local connectivity lists
+        void checkConnectivity(const label maxErrors = 0) const;
+
+        // Test an edge / face for proximity with other non-neighbouring faces.
+        // Return the scalar distance to the nearest face.
+        scalar testProximity
+        (
+            const label index,
+            label& proximityFace
+        ) const;
+
+        // Calculate the edge length-scale for the mesh
+        void calculateLengthScale(bool dump = false);
+
+        // Read optional dictionary parameters
+        void readOptionalParameters(bool reRead = false);
+
+        // Dump cell-quality statistics
+        bool meshQuality(bool outputOption);
+
+public:
+
+    // Declare the name of the class and its debug switch
+        TypeName("dynamicTopoFvMesh");
+
+    // Constructors
+
+        //- Construct from existing IOobject
+        explicit dynamicTopoFvMesh(const IOobject& io);
+
+    // Destructor
+
+        virtual ~dynamicTopoFvMesh();
+
+    // Member Functions
+
+        // Map all fields in time using a customized mapper
+        virtual void mapFields(const mapPolyMesh& meshMap) const;
+
+        // Update the mesh for motion / topology changes
+        // Return true if topology changes have occurred
+        virtual bool update();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "dynamicTopoFvMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
new file mode 100644
index 000000000..42c809080
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshCheck.C
@@ -0,0 +1,1870 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    Functions specific to connectivity checking and debugging
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "dynamicTopoFvMesh.H"
+
+#include "IOmanip.H"
+#include "volFields.H"
+#include "triPointRef.H"
+#include "tetPointRef.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Compute mesh-quality, and return true if no slivers are present
+bool dynamicTopoFvMesh::meshQuality
+(
+    bool outputOption
+)
+{
+    // Compute statistics on the fly
+    label nCells = 0, minCell = -1;
+    scalar maxQuality = -GREAT;
+    scalar minQuality =  GREAT;
+    scalar cQuality, meanQuality = 0.0;
+
+    // Track slivers
+    bool sliversAbsent = true;
+    thresholdSlivers_.clear();
+
+    // Loop through all cells in the mesh and compute cell quality
+    forAll(cells_, cellI)
+    {
+        const cell& cellToCheck = cells_[cellI];
+
+        if (cellToCheck.empty())
+        {
+            continue;
+        }
+
+        if (twoDMesh_)
+        {
+            // Assume XY plane here
+            vector n = vector(0,0,1);
+
+            // Get a triangular boundary face
+            forAll(cellToCheck, faceI)
+            {
+                const face& faceToCheck = faces_[cellToCheck[faceI]];
+
+                if (faceToCheck.size() == 3)
+                {
+                    triPointRef tpr
+                    (
+                        points_[faceToCheck[0]],
+                        points_[faceToCheck[1]],
+                        points_[faceToCheck[2]]
+                    );
+
+                    // Assume centre-plane passes through origin
+                    cQuality =
+                    (
+                        tpr.quality() *
+                        (
+                            Foam::sign
+                            (
+                                tpr.normal() &
+                                ((tpr.centre() & n) * n)
+                            )
+                        )
+                    );
+
+                    break;
+                }
+            }
+        }
+        else
+        {
+            const label bfIndex = cellToCheck[0];
+            const label cfIndex = cellToCheck[1];
+
+            const face& baseFace = faces_[bfIndex];
+            const face& checkFace = faces_[cfIndex];
+
+            // Get the fourth point
+            label apexPoint =
+            (
+                meshOps::findIsolatedPoint(baseFace, checkFace)
+            );
+
+            // Compute cell quality
+            if (owner_[bfIndex] == cellI)
+            {
+                cQuality =
+                (
+                    tetMetric_
+                    (
+                        points_[baseFace[2]],
+                        points_[baseFace[1]],
+                        points_[baseFace[0]],
+                        points_[apexPoint]
+                    )
+                );
+            }
+            else
+            {
+                cQuality =
+                (
+                    tetMetric_
+                    (
+                        points_[baseFace[0]],
+                        points_[baseFace[1]],
+                        points_[baseFace[2]],
+                        points_[apexPoint]
+                    )
+                );
+            }
+        }
+
+        // Update statistics
+        maxQuality = Foam::max(cQuality, maxQuality);
+
+        if (cQuality < minQuality)
+        {
+            minQuality = cQuality;
+            minCell = cellI;
+        }
+
+        meanQuality += cQuality;
+        nCells++;
+
+        // Add to the list of slivers
+        if ((cQuality < sliverThreshold_) && (cQuality > 0.0))
+        {
+            thresholdSlivers_.insert(cellI, cQuality);
+        }
+    }
+
+    if (thresholdSlivers_.size())
+    {
+        sliversAbsent = false;
+    }
+
+    // Reduce across processors.
+    reduce(sliversAbsent, andOp<bool>());
+
+    // Output statistics:
+    if (outputOption || (debug > 0))
+    {
+        // 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 << endl;
+        Info << " ~~~ Mesh Quality Statistics ~~~ " << endl;
+        Info << " Min: " << minQuality << endl;
+        Info << " Max: " << maxQuality << endl;
+        Info << " Mean: " << meanQuality/nCells << endl;
+        Info << " Cells: " << nCells << endl;
+        Info << " ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ " << nl << endl;
+    }
+
+    return sliversAbsent;
+}
+
+
+// Utility to check whether points of an edge lie on a boundary.
+const FixedList<bool,2>
+dynamicTopoFvMesh::checkEdgeBoundary
+(
+    const label eIndex
+) const
+{
+    FixedList<bool,2> edgeBoundary(false);
+
+    const edge& edgeToCheck = edges_[eIndex];
+
+    // Loop through edges connected to both points,
+    // and check if any of them lie on boundaries.
+    // Used to ensure that collapses happen towards boundaries.
+    forAll(edgeToCheck, pointI)
+    {
+        const labelList& pEdges = pointEdges_[edgeToCheck[pointI]];
+
+        forAll(pEdges, edgeI)
+        {
+            // Determine the patch this edge belongs to
+            if (whichEdgePatch(pEdges[edgeI]) > -1)
+            {
+                edgeBoundary[pointI] = true;
+                break;
+            }
+        }
+    }
+
+    return edgeBoundary;
+}
+
+
+// Check whether the given edge is on a bounding curve
+bool dynamicTopoFvMesh::checkBoundingCurve(const label eIndex) const
+{
+    // Internal edges don't count
+    label edgePatch = -1;
+
+    if ((edgePatch = whichEdgePatch(eIndex)) < 0)
+    {
+        return false;
+    }
+    else
+    {
+        // Check whether this edge shouldn't be swapped
+        if (findIndex(noSwapPatchIDs_, edgePatch) > -1)
+        {
+            return true;
+        }
+    }
+
+    // Check if two boundary faces lie on different face-patches
+    FixedList<vector, 2> fNorm(vector::zero);
+    label fPatch, firstPatch = -1, secondPatch = -1, count = 0;
+    const labelList& edgeFaces = edgeFaces_[eIndex];
+
+    forAll(edgeFaces, faceI)
+    {
+        if ((fPatch = whichPatch(edgeFaces[faceI])) > -1)
+        {
+            // Obtain the normal.
+            meshOps::faceNormal
+            (
+                faces_[edgeFaces[faceI]],
+                points_,
+                fNorm[count]
+            );
+
+            // Normalize it.
+            fNorm[count] /= mag(fNorm[count]) + VSMALL;
+
+            count++;
+
+            if (firstPatch == -1)
+            {
+                firstPatch = fPatch;
+            }
+            else
+            {
+                secondPatch = fPatch;
+                break;
+            }
+        }
+    }
+
+    scalar deviation = (fNorm[0] & fNorm[1]);
+
+    // Check if the swap-curvature is too high
+    if (mag(deviation) < swapDeviation_)
+    {
+        return true;
+    }
+
+    // Check if the edge borders two different patches
+    if (firstPatch != secondPatch)
+    {
+        return true;
+    }
+
+    // Not on a bounding curve
+    return false;
+}
+
+
+// Check triangulation quality for an edge index
+bool dynamicTopoFvMesh::checkQuality
+(
+    const label eIndex,
+    const labelList& m,
+    const PtrList<scalarListList>& Q,
+    const scalar minQuality,
+    const label checkIndex
+) const
+{
+    bool myResult = false;
+
+    // Non-coupled check
+    if (Q[checkIndex][0][m[checkIndex]-1] > minQuality)
+    {
+        myResult = true;
+
+        if (debug > 2)
+        {
+            Info << nl << nl
+                 << " eIndex: " << eIndex
+                 << " minQuality: " << minQuality
+                 << " newQuality: " << Q[checkIndex][0][m[checkIndex]-1]
+                 << endl;
+        }
+    }
+
+    return myResult;
+}
+
+
+// Print out tables for debugging
+void dynamicTopoFvMesh::printTables
+(
+    const labelList& m,
+    const PtrList<scalarListList>& Q,
+    const PtrList<labelListList>& K,
+    const label checkIndex
+) const
+{
+    Info << "m: " << m[checkIndex] << endl;
+
+    // Print out Q
+    Info << "===" << endl;
+    Info << " Q " << endl;
+    Info << "===" << endl;
+
+    Info << "   ";
+
+    for (label j = 0; j < m[checkIndex]; j++)
+    {
+        Info << setw(12) << j;
+    }
+
+    Info << nl;
+
+    for (label j = 0; j < m[checkIndex]; j++)
+    {
+        Info << "-------------";
+    }
+
+    Info << nl;
+
+    for (label i = 0; i < (m[checkIndex]-2); i++)
+    {
+        Info << i << ": ";
+
+        for (label j = 0; j < m[checkIndex]; j++)
+        {
+            Info << setw(12) << Q[checkIndex][i][j];
+        }
+
+        Info << nl;
+    }
+
+    // Print out K
+    Info << "===" << endl;
+    Info << " K " << endl;
+    Info << "===" << endl;
+
+    Info << "   ";
+
+    for (label j = 0; j < m[checkIndex]; j++)
+    {
+        Info << setw(12) << j;
+    }
+
+    Info << nl;
+
+    for (label i = 0; i < (m[checkIndex]-2); i++)
+    {
+        Info << i << ": ";
+
+        for (label j = 0; j < m[checkIndex]; j++)
+        {
+            Info << setw(12) << K[checkIndex][i][j];
+        }
+
+        Info << nl;
+    }
+
+    Info << endl;
+}
+
+
+// Check old-volumes for an input triangulation
+bool dynamicTopoFvMesh::checkTriangulationVolumes
+(
+    const label eIndex,
+    const labelList& hullVertices,
+    const labelListList& triangulations
+) const
+{
+    label m = hullVertices.size();
+    scalar tetVol = 0.0;
+
+    const edge& edgeToCheck = edges_[eIndex];
+
+    for (label i = 0; i < (m-2); i++)
+    {
+        // Compute volume for the upper-half
+        tetVol =
+        (
+            tetPointRef
+            (
+                oldPoints_[hullVertices[triangulations[0][i]]],
+                oldPoints_[hullVertices[triangulations[1][i]]],
+                oldPoints_[hullVertices[triangulations[2][i]]],
+                oldPoints_[edgeToCheck[0]]
+            ).mag()
+        );
+
+        if (tetVol < 0.0)
+        {
+            if (debug > 2)
+            {
+                InfoIn
+                (
+                    "bool dynamicTopoFvMesh::checkTriangulationVolumes\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const labelList& hullVertices,\n"
+                    "    const labelListList& triangulations\n"
+                    ") const\n"
+                )
+                    << "Swap sequence leads to negative old-volumes." << nl
+                    << "Edge: " << edgeToCheck << nl
+                    << "using Points: " << nl
+                    << oldPoints_[hullVertices[triangulations[0][i]]] << nl
+                    << oldPoints_[hullVertices[triangulations[1][i]]] << nl
+                    << oldPoints_[hullVertices[triangulations[2][i]]] << nl
+                    << oldPoints_[edgeToCheck[0]] << endl;
+            }
+
+            return true;
+        }
+
+        tetVol =
+        (
+            tetPointRef
+            (
+                oldPoints_[hullVertices[triangulations[2][i]]],
+                oldPoints_[hullVertices[triangulations[1][i]]],
+                oldPoints_[hullVertices[triangulations[0][i]]],
+                oldPoints_[edgeToCheck[1]]
+            ).mag()
+        );
+
+        if (tetVol < 0.0)
+        {
+            if (debug > 2)
+            {
+                InfoIn
+                (
+                    "bool dynamicTopoFvMesh::checkTriangulationVolumes\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    const labelList& hullVertices,\n"
+                    "    const labelListList& triangulations\n"
+                    ") const\n"
+                )
+                    << "Swap sequence leads to negative old-volumes." << nl
+                    << "Edge: " << edgeToCheck << nl
+                    << "using Points: " << nl
+                    << oldPoints_[hullVertices[triangulations[2][i]]] << nl
+                    << oldPoints_[hullVertices[triangulations[1][i]]] << nl
+                    << oldPoints_[hullVertices[triangulations[0][i]]] << nl
+                    << oldPoints_[edgeToCheck[1]] << endl;
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+// Output an entity as a VTK file
+void dynamicTopoFvMesh::writeVTK
+(
+    const word& name,
+    const label entity,
+    const label primitiveType,
+    const bool useOldConnectivity,
+    const bool useOldPoints
+) const
+{
+    writeVTK
+    (
+        name,
+        labelList(1, entity),
+        primitiveType,
+        useOldConnectivity,
+        useOldPoints
+    );
+}
+
+
+// Output a list of primitives as a VTK file.
+//  - primitiveType is:
+//      0: List of points
+//      1: List of edges
+//      2: List of faces
+//      3: List of cells
+void dynamicTopoFvMesh::writeVTK
+(
+    const word& name,
+    const labelList& cList,
+    const label primitiveType,
+    const bool useOldConnectivity,
+    const bool useOldPoints
+) const
+{
+    if (useOldPoints)
+    {
+        if (useOldConnectivity)
+        {
+            // Use points from polyMesh
+            meshOps::writeVTK
+            (
+                (*this),
+                name,
+                cList,
+                primitiveType,
+                polyMesh::points(),
+                polyMesh::edges(),
+                polyMesh::faces(),
+                polyMesh::cells(),
+                polyMesh::faceOwner()
+            );
+        }
+        else
+        {
+            meshOps::writeVTK
+            (
+                (*this),
+                name,
+                cList,
+                primitiveType,
+                oldPoints_,
+                edges_,
+                faces_,
+                cells_,
+                owner_
+            );
+        }
+    }
+    else
+    {
+        meshOps::writeVTK
+        (
+            (*this),
+            name,
+            cList,
+            primitiveType,
+            points_,
+            edges_,
+            faces_,
+            cells_,
+            owner_
+        );
+    }
+}
+
+
+// Return the status report interval
+scalar dynamicTopoFvMesh::reportInterval() const
+{
+    // Default to 3 seconds
+    scalar interval = 3.0;
+
+    const dictionary& meshSubDict = dict_.subDict("dynamicTopoFvMesh");
+
+    if (meshSubDict.found("reportInterval") || mandatory_)
+    {
+        interval = readScalar(meshSubDict.lookup("reportInterval"));
+
+        // Prevent reports if necessary
+        if (interval < VSMALL)
+        {
+            interval = GREAT;
+        }
+    }
+
+    return interval;
+}
+
+
+// Check the state of connectivity lists
+void dynamicTopoFvMesh::checkConnectivity(const label maxErrors) const
+{
+    label nFailedChecks = 0;
+
+    messageStream ConnectivityWarning
+    (
+        "dynamicTopoFvMesh Connectivity Warning",
+        messageStream::SERIOUS,
+        maxErrors
+    );
+
+    // Check face-label ranges
+    Info << "Checking index ranges...";
+
+    forAll(edges_, edgeI)
+    {
+        const edge& curEdge = edges_[edgeI];
+
+        if (curEdge == edge(-1, -1))
+        {
+            continue;
+        }
+
+        if
+        (
+            curEdge[0] < 0 || curEdge[0] > (points_.size()-1) ||
+            curEdge[1] < 0 || curEdge[1] > (points_.size()-1)
+        )
+        {
+            Pout << "Edge " << edgeI
+                 << " contains vertex labels out of range: "
+                 << curEdge
+                 << " Max point index = " << (points_.size()-1) << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Edge-point connectivity is inconsistent."
+                 << endl;
+        }
+
+        // Check for unique point-labels
+        if (curEdge[0] == curEdge[1])
+        {
+            Pout << "Edge " << edgeI
+                 << " contains identical vertex labels: "
+                 << curEdge
+                 << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Edge-point connectivity is inconsistent."
+                 << endl;
+        }
+    }
+
+    label allPoints = points_.size();
+    labelList nPointFaces(allPoints, 0);
+
+    forAll(faces_, faceI)
+    {
+        const face& curFace = faces_[faceI];
+
+        if (curFace.empty())
+        {
+            continue;
+        }
+
+        if (min(curFace) < 0 || max(curFace) > (points_.size()-1))
+        {
+            Pout << "Face " << faceI
+                 << " contains vertex labels out of range: "
+                 << curFace
+                 << " Max point index = " << (points_.size()-1) << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Face-point connectivity is inconsistent."
+                 << endl;
+        }
+
+        // Check for unique point-labels
+        labelHashSet uniquePoints;
+
+        forAll(curFace, pointI)
+        {
+            bool inserted = uniquePoints.insert(curFace[pointI]);
+
+            if (!inserted)
+            {
+                Pout << "Face " << faceI
+                     << " contains identical vertex labels: "
+                     << curFace
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                     << nl << "Face-point connectivity is inconsistent."
+                     << endl;
+            }
+        }
+
+        // Count faces per point
+        forAll(curFace, pointI)
+        {
+            nPointFaces[curFace[pointI]]++;
+        }
+
+        // Ensure that cells on either side of this face
+        // share just one face.
+        if (neighbour_[faceI] > -1)
+        {
+            const cell& ownCell = cells_[owner_[faceI]];
+            const cell& neiCell = cells_[neighbour_[faceI]];
+
+            label nCommon = 0;
+
+            forAll(ownCell, fi)
+            {
+                if (findIndex(neiCell, ownCell[fi]) > -1)
+                {
+                    nCommon++;
+                }
+            }
+
+            if (nCommon != 1)
+            {
+                Pout << "Cells: " << nl
+                     << '\t' << owner_[faceI] << ":: " << ownCell << nl
+                     << '\t' << neighbour_[faceI] << " :: " << neiCell << nl
+                     << " share multiple faces. "
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                     << nl << "Cell-Face connectivity is inconsistent."
+                     << endl;
+            }
+        }
+    }
+
+    label allFaces = faces_.size();
+    labelList nCellsPerFace(allFaces, 0);
+
+    forAll(cells_, cellI)
+    {
+        const cell& curCell = cells_[cellI];
+
+        if (curCell.empty())
+        {
+            continue;
+        }
+
+        if (min(curCell) < 0 || max(curCell) > (faces_.size()-1))
+        {
+            Pout << "Cell " << cellI
+                 << " contains vertex labels out of range: "
+                 << curCell
+                 << " Max point index = " << (faces_.size()-1) << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Cell-Face connectivity is inconsistent."
+                 << endl;
+        }
+
+        // Check for unique face-labels
+        labelHashSet uniqueFaces;
+
+        forAll(curCell, faceI)
+        {
+            bool inserted = uniqueFaces.insert(curCell[faceI]);
+
+            if (!inserted)
+            {
+                Pout << "Cell " << cellI
+                     << " contains identical face labels: "
+                     << curCell
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                     << nl << "Cell-Face connectivity is inconsistent."
+                     << endl;
+            }
+
+            // Count cells per face
+            nCellsPerFace[curCell[faceI]]++;
+        }
+    }
+
+    Info << "Done." << endl;
+
+    Info << "Checking face-cell connectivity...";
+
+    forAll(nCellsPerFace, faceI)
+    {
+        if (nCellsPerFace[faceI] == 0)
+        {
+            // This might be a deleted face
+            if (faceI < nOldFaces_)
+            {
+                if (reverseFaceMap_[faceI] == -1)
+                {
+                    continue;
+                }
+            }
+            else
+            {
+                if (deletedFaces_.found(faceI))
+                {
+                    continue;
+                }
+            }
+
+            // Looks like this is really an unused face.
+            Pout << "Face " << faceI
+                 << " :: " << faces_[faceI]
+                 << " is unused. "
+                 << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Cell-Face connectivity is inconsistent."
+                 << endl;
+        }
+        else
+        if (nCellsPerFace[faceI] != 2 && whichPatch(faceI) == -1)
+        {
+            // Internal face is not shared by exactly two cells
+            Pout << "Internal Face " << faceI
+                 << " :: " << faces_[faceI]
+                 << " is multiply connected." << nl
+                 << " nCellsPerFace: " << nCellsPerFace[faceI]
+                 << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Cell-Face connectivity is inconsistent."
+                 << endl;
+        }
+        else
+        if (nCellsPerFace[faceI] != 1 && whichPatch(faceI) > -1)
+        {
+            // Boundary face is not shared by exactly one cell
+            Pout << "Boundary Face " << faceI
+                 << " :: " << faces_[faceI]
+                 << " is multiply connected." << nl
+                 << " nCellsPerFace: " << nCellsPerFace[faceI]
+                 << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Cell-Face connectivity is inconsistent."
+                 << endl;
+        }
+    }
+
+    Info << "Done." << endl;
+
+    Info << "Checking for unused points...";
+
+    forAll(nPointFaces, pointI)
+    {
+        if (nPointFaces[pointI] == 0)
+        {
+            // This might be a deleted point.
+            if (pointI < nOldPoints_)
+            {
+                if (reversePointMap_[pointI] == -1)
+                {
+                    continue;
+                }
+            }
+            else
+            {
+                if (deletedPoints_.found(pointI))
+                {
+                    continue;
+                }
+            }
+
+            // Looks like this is really an unused point.
+            Pout << "Point " << pointI << " is unused. " << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                 << nl << "Point-Face connectivity is inconsistent."
+                 << endl;
+        }
+    }
+
+    Info << "Done." << endl;
+
+    Info << "Checking edge-face connectivity...";
+
+    label allEdges = edges_.size();
+    labelList nEdgeFaces(allEdges, 0);
+
+    forAll(faceEdges_, faceI)
+    {
+        const labelList& faceEdges = faceEdges_[faceI];
+
+        if (faceEdges.empty())
+        {
+            continue;
+        }
+
+        // Check consistency of face-edge-points as well
+        edgeList eList = faces_[faceI].edges();
+
+        forAll(faceEdges,edgeI)
+        {
+            nEdgeFaces[faceEdges[edgeI]]++;
+
+            // Check if this edge actually belongs to this face
+            bool found = false;
+            const edge& edgeToCheck = edges_[faceEdges[edgeI]];
+
+            forAll(eList, edgeII)
+            {
+                if (edgeToCheck == eList[edgeII])
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found)
+            {
+                Pout << nl << nl << "Edge: " << faceEdges[edgeI]
+                     << ": " << edgeToCheck << nl
+                     << "was not found in face: " << faceI
+                     << ": " << faces_[faceI] << nl
+                     << "faceEdges: " << faceEdges
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                     << nl << "Edge-Face connectivity is inconsistent."
+                     << endl;
+            }
+        }
+    }
+
+    label nInternalEdges = 0;
+    labelList patchInfo(boundaryMesh().size(), 0);
+
+    forAll(edgeFaces_, edgeI)
+    {
+        const labelList& edgeFaces = edgeFaces_[edgeI];
+
+        if (edgeFaces.empty())
+        {
+            continue;
+        }
+
+        if (edgeFaces.size() != nEdgeFaces[edgeI])
+        {
+            Pout << nl << nl << "Edge: " << edgeI
+                 << ": edgeFaces: " << edgeFaces << endl;
+
+            nFailedChecks++;
+
+            ConnectivityWarning()
+                << nl << "Edge-Face connectivity is inconsistent."
+                << endl;
+        }
+
+        label nBF = 0;
+
+        // Check if this edge belongs to faceEdges for each face
+        forAll(edgeFaces, faceI)
+        {
+            if (findIndex(faceEdges_[edgeFaces[faceI]], edgeI) == -1)
+            {
+                Pout << nl << nl << "Edge: " << edgeI << ": " << edges_[edgeI]
+                     << ", edgeFaces: " << edgeFaces << nl
+                     << "was not found in faceEdges of face: "
+                     << edgeFaces[faceI] << ": " << faces_[edgeFaces[faceI]]
+                     << nl << "faceEdges: " << faceEdges_[edgeFaces[faceI]]
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                    << nl << "Edge-Face connectivity is inconsistent."
+                    << endl;
+            }
+
+            if (neighbour_[edgeFaces[faceI]] == -1)
+            {
+                nBF++;
+            }
+        }
+
+        if (nBF == 0)
+        {
+            nInternalEdges++;
+
+            // Check if this edge is actually internal.
+            if (whichEdgePatch(edgeI) >= 0)
+            {
+                Pout << "Edge: " << edgeI
+                     << ": " << edges_[edgeI] << " is internal, "
+                     << " but patch is specified as: "
+                     << whichEdgePatch(edgeI)
+                     << endl;
+
+                nFailedChecks++;
+            }
+        }
+        else
+        {
+            label patchID = whichEdgePatch(edgeI);
+
+            // Check if this edge is actually on a boundary.
+            if (patchID < 0)
+            {
+                Pout << "Edge: " << edgeI
+                     << ": " << edges_[edgeI]
+                     << " is on a boundary, but patch is specified as: "
+                     << patchID << endl;
+
+                nFailedChecks++;
+            }
+            else
+            {
+                patchInfo[patchID]++;
+            }
+
+            if (nBF > 2)
+            {
+                Pout << "Edge: " << edgeI
+                     << ": " << edges_[edgeI]
+                     << " has " << nBF
+                     << " boundary faces connected to it." << nl
+                     << " Pinched manifolds are not allowed."
+                     << endl;
+
+                nFailedChecks++;
+            }
+        }
+    }
+
+    if (nInternalEdges != nInternalEdges_)
+    {
+        Pout << nl << "Internal edge-count is inconsistent." << nl
+             << " Counted internal edges: " << nInternalEdges
+             << " Actual count: " << nInternalEdges_ << endl;
+
+        nFailedChecks++;
+    }
+
+    forAll(patchInfo, patchI)
+    {
+        if (patchInfo[patchI] != edgePatchSizes_[patchI])
+        {
+            Pout << "Patch-count is inconsistent." << nl
+                 << " Patch: " << patchI
+                 << " Counted edges: " << patchInfo[patchI]
+                 << " Actual count: " << edgePatchSizes_[patchI] << endl;
+
+            nFailedChecks++;
+        }
+    }
+
+    // Check added edge patches to ensure that it is consistent
+    forAllConstIter(Map<label>, addedEdgePatches_, aepIter)
+    {
+        label key = aepIter.key();
+        label patch = aepIter();
+
+        label nBF = 0;
+        const labelList& edgeFaces = edgeFaces_[key];
+
+        // Check if any faces on boundaries
+        forAll(edgeFaces, faceI)
+        {
+            if (neighbour_[edgeFaces[faceI]] == -1)
+            {
+                nBF++;
+            }
+        }
+
+        if ((patch < 0) && (nBF > 0))
+        {
+            Pout << nl << nl << "Edge: " << key
+                 << ", edgeFaces: " << edgeFaces
+                 << " is internal, but contains boundary faces."
+                 << endl;
+
+            nFailedChecks++;
+        }
+
+        if ((patch >= 0) && (nBF != 2))
+        {
+            Pout << nl << nl << "Edge: " << key
+                 << ", edgeFaces: " << edgeFaces
+                 << " is on a boundary patch, but doesn't contain"
+                 << " two boundary faces."
+                 << endl;
+
+            nFailedChecks++;
+        }
+    }
+
+    Info << "Done." << endl;
+
+    if (!twoDMesh_)
+    {
+        Info << "Checking point-edge connectivity...";
+
+        label allPoints = points_.size();
+        List<labelHashSet> hlPointEdges(allPoints);
+
+        forAll(edges_, edgeI)
+        {
+            if (edgeFaces_[edgeI].size())
+            {
+                hlPointEdges[edges_[edgeI][0]].insert(edgeI);
+                hlPointEdges[edges_[edgeI][1]].insert(edgeI);
+            }
+        }
+
+        forAll(pointEdges_, pointI)
+        {
+            const labelList& pointEdges = pointEdges_[pointI];
+
+            if (pointEdges.empty())
+            {
+                continue;
+            }
+
+            forAll(pointEdges, edgeI)
+            {
+                if (!hlPointEdges[pointI].found(pointEdges[edgeI]))
+                {
+                    Pout << nl << nl << "Point: " << pointI << nl
+                         << "pointEdges: " << pointEdges << nl
+                         << "hlPointEdges: " << hlPointEdges[pointI]
+                         << endl;
+
+                    nFailedChecks++;
+
+                    ConnectivityWarning()
+                        << nl << "Point-Edge connectivity is inconsistent."
+                        << endl;
+                }
+            }
+
+            // Do a size check as well
+            if
+            (
+                hlPointEdges[pointI].size() != pointEdges.size() ||
+                pointEdges.size() == 1
+            )
+            {
+                Pout << nl << nl << "Point: " << pointI << nl
+                     << "pointEdges: " << pointEdges << nl
+                     << "hlPointEdges: " << hlPointEdges[pointI]
+                     << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                    << "Size inconsistency."
+                    << nl << "Point-Edge connectivity is inconsistent."
+                    << endl;
+            }
+        }
+
+        Info << "Done." << endl;
+
+        Info << "Checking edge-points connectivity...";
+
+        label otherPoint = -1, nextPoint = -1;
+
+        forAll(edgePoints_, edgeI)
+        {
+            // Do a preliminary size check
+            const labelList& edgePoints = edgePoints_[edgeI];
+            const labelList& edgeFaces = edgeFaces_[edgeI];
+
+            if (edgeFaces.empty())
+            {
+                continue;
+            }
+
+            if (edgePoints.size() != edgeFaces.size())
+            {
+                Pout << nl << nl
+                     << "Edge: " << edgeI
+                     << " " << edges_[edgeI] << endl;
+
+                Pout << "edgeFaces: " << edgeFaces << endl;
+                forAll(edgeFaces, faceI)
+                {
+                    Info << edgeFaces[faceI] << ": "
+                         << faces_[edgeFaces[faceI]]
+                         << endl;
+                }
+
+                Pout << "edgePoints: " << edgePoints << endl;
+
+                nFailedChecks++;
+
+                ConnectivityWarning()
+                    << nl << "Edge-Points connectivity is inconsistent."
+                    << endl;
+            }
+
+            // Now check to see that both lists are consistent.
+            const edge& edgeToCheck = edges_[edgeI];
+
+            forAll(edgeFaces, faceI)
+            {
+                const face& faceToCheck = faces_[edgeFaces[faceI]];
+
+                meshOps::findIsolatedPoint
+                (
+                    faceToCheck,
+                    edgeToCheck,
+                    otherPoint,
+                    nextPoint
+                );
+
+                if (findIndex(edgePoints, otherPoint) == -1)
+                {
+                    Pout << nl << nl
+                         << "Edge: " << edgeI
+                         << " " << edges_[edgeI] << endl;
+
+                    Pout << "edgeFaces: " << edgeFaces << endl;
+                    forAll(edgeFaces, faceI)
+                    {
+                        Info << edgeFaces[faceI] << ": "
+                             << faces_[edgeFaces[faceI]]
+                             << endl;
+                    }
+
+                    Pout << "edgePoints: " << edgePoints << endl;
+
+                    nFailedChecks++;
+
+                    ConnectivityWarning()
+                        << nl << "Edge-Points connectivity is inconsistent."
+                        << endl;
+                }
+            }
+        }
+
+        Info << "Done." << endl;
+    }
+
+    Info << "Checking cell-point connectivity...";
+
+    // Loop through all cells and construct cell-to-node
+    label cIndex = 0;
+    label allCells = cells_.size();
+    labelList cellIndex(allCells);
+    List<labelHashSet> cellToNode(allCells);
+
+    forAll(cells_, cellI)
+    {
+        const cell& thisCell = cells_[cellI];
+
+        if (thisCell.empty())
+        {
+            continue;
+        }
+
+        cellIndex[cIndex] = cellI;
+
+        forAll(thisCell, faceI)
+        {
+            const labelList& fEdges = faceEdges_[thisCell[faceI]];
+
+            forAll(fEdges, edgeI)
+            {
+                const edge& thisEdge = edges_[fEdges[edgeI]];
+
+                if (!cellToNode[cIndex].found(thisEdge[0]))
+                {
+                    cellToNode[cIndex].insert(thisEdge[0]);
+                }
+
+                if (!cellToNode[cIndex].found(thisEdge[1]))
+                {
+                    cellToNode[cIndex].insert(thisEdge[1]);
+                }
+            }
+        }
+
+        cIndex++;
+    }
+
+    // Resize the lists
+    cellIndex.setSize(cIndex);
+    cellToNode.setSize(cIndex);
+
+    // Preliminary check for size
+    forAll(cellToNode, cellI)
+    {
+        if
+        (
+            (cellToNode[cellI].size() != 6 && twoDMesh_) ||
+            (cellToNode[cellI].size() != 4 && !twoDMesh_)
+        )
+        {
+            Pout << nl << "Warning: Cell: "
+                 << cellIndex[cellI] << " is inconsistent. "
+                 << endl;
+
+            const cell& failedCell = cells_[cellIndex[cellI]];
+
+            Info << "Cell faces: " << failedCell << endl;
+
+            forAll(failedCell, faceI)
+            {
+                Info << "\tFace: " << failedCell[faceI]
+                     << " :: " << faces_[failedCell[faceI]]
+                     << endl;
+
+                const labelList& fEdges = faceEdges_[failedCell[faceI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    Info << "\t\tEdge: " << fEdges[edgeI]
+                         << " :: " << edges_[fEdges[edgeI]]
+                         << endl;
+                }
+            }
+
+            nFailedChecks++;
+        }
+    }
+
+    Info << "Done." << endl;
+
+    reduce(nFailedChecks, orOp<bool>());
+
+    if (nFailedChecks)
+    {
+        FatalErrorIn
+        (
+            "void dynamicTopoFvMesh::checkConnectivity"
+            "(const label maxErrors) const"
+        )
+            << nFailedChecks << " failures were found in connectivity."
+            << abort(FatalError);
+    }
+}
+
+
+// Utility method to check the quality
+// of a triangular face after bisection.
+//  - Returns 'true' if the bisection in NOT feasible.
+bool dynamicTopoFvMesh::checkBisection
+(
+    const label fIndex,
+    const label bFaceIndex,
+    bool forceOp
+) const
+{
+    scalar bisectionQuality = GREAT, minArea = GREAT;
+
+    label commonEdge = -1;
+
+    // Find the common edge index
+    meshOps::findCommonEdge
+    (
+        bFaceIndex,
+        fIndex,
+        faceEdges_,
+        commonEdge
+    );
+
+    // Fetch the edge
+    const edge& checkEdge = edges_[commonEdge];
+    const face& checkFace = faces_[bFaceIndex];
+
+    // Compute old / new mid-points
+    point mpOld =
+    (
+        linePointRef
+        (
+            oldPoints_[checkEdge.start()],
+            oldPoints_[checkEdge.end()]
+        ).centre()
+    );
+
+    point mpNew =
+    (
+        linePointRef
+        (
+            points_[checkEdge.start()],
+            points_[checkEdge.end()]
+        ).centre()
+    );
+
+    // Find the isolated point on the face
+    label iPoint = -1, nPoint = -1;
+
+    meshOps::findIsolatedPoint
+    (
+        checkFace,
+        checkEdge,
+        iPoint,
+        nPoint
+    );
+
+    // Find the other point
+    label oPoint =
+    (
+        (nPoint == checkEdge.start()) ?
+        checkEdge.end() : checkEdge.start()
+    );
+
+    // Configure old / new triangle faces
+    FixedList<FixedList<point, 3>, 2> tfNew, tfOld;
+
+    tfNew[0][0] = mpNew;
+    tfNew[0][1] = points_[iPoint];
+    tfNew[0][2] = points_[nPoint];
+
+    tfOld[0][0] = mpOld;
+    tfOld[0][1] = oldPoints_[iPoint];
+    tfOld[0][2] = oldPoints_[nPoint];
+
+    tfNew[1][0] = points_[oPoint];
+    tfNew[1][1] = points_[iPoint];
+    tfNew[1][2] = mpNew;
+
+    tfOld[1][0] = oldPoints_[oPoint];
+    tfOld[1][1] = oldPoints_[iPoint];
+    tfOld[1][2] = mpOld;
+
+    // Assume XY plane here
+    vector n = vector(0,0,1);
+
+    forAll(tfNew, fI)
+    {
+        // Configure triangles
+        triPointRef tprNew(tfNew[fI][0], tfNew[fI][1], tfNew[fI][2]);
+        triPointRef tprOld(tfOld[fI][0], tfOld[fI][1], tfOld[fI][2]);
+
+        scalar tQuality =
+        (
+            tprNew.quality() *
+            (
+                Foam::sign
+                (
+                    tprNew.normal() &
+                    ((tprNew.centre() & n) * n)
+                )
+            )
+        );
+
+        scalar oldArea =
+        (
+            mag(tprOld.normal()) *
+            (
+                Foam::sign
+                (
+                    tprOld.normal() &
+                    ((tprOld.centre() & n) * n)
+                )
+            )
+        );
+
+        // Update statistics
+        minArea = Foam::min(minArea, oldArea);
+        bisectionQuality = Foam::min(bisectionQuality, tQuality);
+    }
+
+    // Final quality check
+    if (bisectionQuality < sliverThreshold_ && !forceOp)
+    {
+        return true;
+    }
+
+    // Negative quality is a no-no
+    if (bisectionQuality < 0.0)
+    {
+        return true;
+    }
+
+    // Negative old-area is also a no-no
+    if (minArea < 0.0)
+    {
+        return true;
+    }
+
+    // No problems, so a bisection is feasible.
+    return false;
+}
+
+
+// Utility method to check whether the cell given by 'cellIndex' will yield
+// a valid cell when 'pointIndex' is moved to 'newPoint'.
+//  - The routine performs metric-based checks.
+//  - Returns 'true' if the collapse in NOT feasible, and
+//    makes entries in cellsChecked to avoid repetitive checks.
+bool dynamicTopoFvMesh::checkCollapse
+(
+    const labelList& triFaces,
+    const FixedList<label,2>& c0BdyIndex,
+    const FixedList<label,2>& c1BdyIndex,
+    const FixedList<label,2>& pointIndex,
+    const FixedList<point,2>& newPoint,
+    const FixedList<point,2>& oldPoint,
+    scalar& collapseQuality,
+    const bool checkNeighbour,
+    bool forceOp
+) const
+{
+    // Reset input
+    collapseQuality = GREAT;
+    scalar minArea = GREAT;
+
+    forAll(triFaces, indexI)
+    {
+        if
+        (
+            (triFaces[indexI] == c0BdyIndex[0])
+         || (triFaces[indexI] == c0BdyIndex[1])
+        )
+        {
+            continue;
+        }
+
+        if (checkNeighbour)
+        {
+            if
+            (
+                (triFaces[indexI] == c1BdyIndex[0])
+             || (triFaces[indexI] == c1BdyIndex[1])
+            )
+            {
+                continue;
+            }
+        }
+
+        const face& checkFace = faces_[triFaces[indexI]];
+
+        // Configure a triangle face
+        FixedList<point, 3> tFNew(vector::zero);
+        FixedList<point, 3> tFOld(vector::zero);
+
+        // Make necessary replacements
+        forAll(checkFace, pointI)
+        {
+            tFNew[pointI] = points_[checkFace[pointI]];
+            tFOld[pointI] = oldPoints_[checkFace[pointI]];
+
+            if (checkFace[pointI] == pointIndex[0])
+            {
+                tFNew[pointI] = newPoint[0];
+                tFOld[pointI] = oldPoint[0];
+            }
+
+            if (checkFace[pointI] == pointIndex[1])
+            {
+                tFNew[pointI] = newPoint[1];
+                tFOld[pointI] = oldPoint[1];
+            }
+        }
+
+        // Configure triangles
+        triPointRef tprNew(tFNew[0], tFNew[1], tFNew[2]);
+        triPointRef tprOld(tFOld[0], tFOld[1], tFOld[2]);
+
+        // Assume XY plane here
+        vector n = vector(0,0,1);
+
+        // Compute the quality.
+        // Assume centre-plane passes through origin
+        scalar tQuality =
+        (
+            tprNew.quality() *
+            (
+                Foam::sign
+                (
+                    tprNew.normal() &
+                    ((tprNew.centre() & n) * n)
+                )
+            )
+        );
+
+        scalar oldArea =
+        (
+            mag(tprOld.normal()) *
+            (
+                Foam::sign
+                (
+                    tprOld.normal() &
+                    ((tprOld.centre() & n) * n)
+                )
+            )
+        );
+
+        // Update statistics
+        minArea = Foam::min(minArea, oldArea);
+        collapseQuality = Foam::min(collapseQuality, tQuality);
+    }
+
+    // Final quality check
+    if (collapseQuality < sliverThreshold_ && !forceOp)
+    {
+        return true;
+    }
+
+    // Negative quality is a no-no
+    if (collapseQuality < 0.0)
+    {
+        return true;
+    }
+
+    // Negative old-area is also a no-no
+    if (minArea < 0.0)
+    {
+        return true;
+    }
+
+    // No problems, so a collapse is feasible.
+    return false;
+}
+
+
+// Utility method to check whether the cell given by 'cellIndex' will yield
+// a valid cell when 'pointIndex' is moved to 'newPoint'.
+//  - The routine performs metric-based checks.
+//  - Returns 'true' if the collapse in NOT feasible, and
+//    makes entries in cellsChecked to avoid repetitive checks.
+bool dynamicTopoFvMesh::checkCollapse
+(
+    const point& newPoint,
+    const point& oldPoint,
+    const label pointIndex,
+    const label cellIndex,
+    labelHashSet& cellsChecked,
+    scalar& collapseQuality,
+    bool forceOp
+) const
+{
+    label faceIndex = -1;
+    scalar cQuality = 0.0, oldVolume = 0.0;
+    const cell& cellToCheck = cells_[cellIndex];
+
+    // Look for a face that doesn't contain 'pointIndex'
+    forAll(cellToCheck, faceI)
+    {
+        const face& currFace = faces_[cellToCheck[faceI]];
+
+        if (currFace.which(pointIndex) < 0)
+        {
+            faceIndex = cellToCheck[faceI];
+            break;
+        }
+    }
+
+    // Compute cell-volume
+    const face& faceToCheck = faces_[faceIndex];
+
+    if (owner_[faceIndex] == cellIndex)
+    {
+        cQuality =
+        (
+            tetMetric_
+            (
+                points_[faceToCheck[2]],
+                points_[faceToCheck[1]],
+                points_[faceToCheck[0]],
+                newPoint
+            )
+        );
+
+        oldVolume =
+        (
+            tetPointRef
+            (
+                oldPoints_[faceToCheck[2]],
+                oldPoints_[faceToCheck[1]],
+                oldPoints_[faceToCheck[0]],
+                oldPoint
+            ).mag()
+        );
+    }
+    else
+    {
+        cQuality =
+        (
+            tetMetric_
+            (
+                points_[faceToCheck[0]],
+                points_[faceToCheck[1]],
+                points_[faceToCheck[2]],
+                newPoint
+            )
+        );
+
+        oldVolume =
+        (
+            tetPointRef
+            (
+                oldPoints_[faceToCheck[0]],
+                oldPoints_[faceToCheck[1]],
+                oldPoints_[faceToCheck[2]],
+                oldPoint
+            ).mag()
+        );
+    }
+
+    // Final quality check
+    if (cQuality < sliverThreshold_ && !forceOp)
+    {
+        if (debug > 3)
+        {
+            InfoIn
+            (
+                "\n\n"
+                "bool dynamicTopoFvMesh::checkCollapse\n"
+                "(\n"
+                "    const point& newPoint,\n"
+                "    const point& oldPoint,\n"
+                "    const label pointIndex,\n"
+                "    const label cellIndex,\n"
+                "    labelHashSet& cellsChecked,\n"
+                "    scalar& collapseQuality,\n"
+                "    bool forceOp\n"
+                ") const\n"
+            )
+                << "\nCollapsing cell: " << cellIndex
+                << " containing points:\n"
+                << faceToCheck[0] << "," << faceToCheck[1] << ","
+                << faceToCheck[2] << "," << pointIndex << nl
+                << "will yield a quality of: " << cQuality
+                << ", when " << pointIndex
+                << " is moved to location: " << nl
+                << newPoint
+                << endl;
+        }
+
+        return true;
+    }
+
+    // Negative quality is a no-no
+    if (cQuality < 0.0)
+    {
+        if (forceOp)
+        {
+            InfoIn
+            (
+                "\n\n"
+                "bool dynamicTopoFvMesh::checkCollapse\n"
+                "(\n"
+                "    const point& newPoint,\n"
+                "    const point& oldPoint,\n"
+                "    const label pointIndex,\n"
+                "    const label cellIndex,\n"
+                "    labelHashSet& cellsChecked,\n"
+                "    scalar& collapseQuality,\n"
+                "    bool forceOp\n"
+                ") const\n"
+            )
+                << "\nCollapsing cell: " << cellIndex
+                << " containing points:\n"
+                << faceToCheck[0] << "," << faceToCheck[1] << ","
+                << faceToCheck[2] << "," << pointIndex << nl
+                << "will yield a quality of: " << cQuality
+                << ", when " << pointIndex
+                << " is moved to location: " << nl
+                << newPoint << nl
+                << "Operation cannot be forced."
+                << endl;
+        }
+
+        return true;
+    }
+
+    // Negative old-volume is also a no-no
+    if (oldVolume < 0.0)
+    {
+        if (forceOp)
+        {
+            InfoIn
+            (
+                "\n\n"
+                "bool dynamicTopoFvMesh::checkCollapse\n"
+                "(\n"
+                "    const point& newPoint,\n"
+                "    const point& oldPoint,\n"
+                "    const label pointIndex,\n"
+                "    const label cellIndex,\n"
+                "    labelHashSet& cellsChecked,\n"
+                "    scalar& collapseQuality,\n"
+                "    bool forceOp\n"
+                ") const\n"
+            )
+                << "\nCollapsing cell: " << cellIndex
+                << " containing points:\n"
+                << faceToCheck[0] << "," << faceToCheck[1] << ","
+                << faceToCheck[2] << "," << pointIndex << nl
+                << "will yield an old-volume of: " << oldVolume
+                << ", when " << pointIndex
+                << " is moved to location: " << nl
+                << oldPoint << nl
+                << "Operation cannot be forced."
+                << endl;
+        }
+
+        return true;
+    }
+
+    // No problems, so a collapse is feasible
+    cellsChecked.insert(cellIndex);
+
+    // Update input quality
+    collapseQuality = Foam::min(collapseQuality, cQuality);
+
+    return false;
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
new file mode 100644
index 000000000..fbdce588e
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshI.H
@@ -0,0 +1,823 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    An implementation of dynamic changes to mesh-topology
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#include "Stack.H"
+#include "meshOps.H"
+#include "tetPointRef.H"
+#include "linePointRef.H"
+#include "lengthScaleEstimator.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Return a non-const reference to the lengthScaleEstimator
+inline lengthScaleEstimator&
+dynamicTopoFvMesh::lengthEstimator()
+{
+    if (!lengthEstimator_.valid())
+    {
+        FatalErrorIn
+        (
+            "inline lengthScaleEstimator& "
+            "dynamicTopoFvMesh::lengthEstimator()"
+        ) << nl
+          << " Invalid request. Length scale estimator was not loaded. "
+          << abort(FatalError);
+    }
+
+    return lengthEstimator_();
+}
+
+
+// Return a const reference to the lengthScaleEstimator
+inline const lengthScaleEstimator&
+dynamicTopoFvMesh::lengthEstimator() const
+{
+    if (!lengthEstimator_.valid())
+    {
+        FatalErrorIn
+        (
+            "inline const lengthScaleEstimator& "
+            "dynamicTopoFvMesh::lengthEstimator() const"
+        ) << nl
+          << " Invalid request. Length scale estimator was not loaded. "
+          << abort(FatalError);
+    }
+
+    return lengthEstimator_();
+}
+
+
+// Return a const reference to the multiThreader
+inline const multiThreader&
+dynamicTopoFvMesh::threader() const
+{
+    if (!threader_.valid())
+    {
+        FatalErrorIn
+        (
+            "inline const multiThreader& "
+            "dynamicTopoFvMesh::threader() const"
+        ) << nl
+          << " Invalid request. multiThreader was not loaded. "
+          << abort(FatalError);
+    }
+
+    return threader_();
+}
+
+
+// Return a reference to the entity mutexes.
+// The index 'entity' ranges from 0 to 3 for point/edge/face/cell.
+inline const Mutex& dynamicTopoFvMesh::entityMutex
+(
+    const label entity
+) const
+{
+    return entityMutex_[entity];
+}
+
+
+// Return the edge index for a provided edge
+inline label dynamicTopoFvMesh::getEdgeIndex
+(
+    const edge& edgeToCheck
+) const
+{
+    if (twoDMesh_)
+    {
+        // No efficient search method. Loop through all edges.
+        forAll(edges_, edgeI)
+        {
+            if (edges_[edgeI] == edgeToCheck)
+            {
+                return edgeI;
+            }
+        }
+    }
+    else
+    {
+        // Look througg pointEdges list
+        const labelList& pEdges = pointEdges_[edgeToCheck.start()];
+
+        forAll(pEdges, edgeI)
+        {
+            if (edges_[pEdges[edgeI]] == edgeToCheck)
+            {
+                return pEdges[edgeI];
+            }
+        }
+    }
+
+    // Probably not a valid edge.
+    FatalErrorIn
+    (
+        "inline label dynamicTopoFvMesh::getEdgeIndex"
+        "(const edge& edgeToCheck) const"
+    )
+        << "Could not find an appropriate edge index for edge:"
+        << edgeToCheck
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+// Given any quad face, pick out a boundary edge that
+// contains a triangular face. For 2D simplical meshes only.
+inline label dynamicTopoFvMesh::getTriBoundaryEdge
+(
+    const label fIndex
+) const
+{
+    const labelList& fEdges = faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        // Obtain edgeFaces for this edge
+        const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+        forAll(eFaces, faceI)
+        {
+            if (faces_[eFaces[faceI]].size() == 3)
+            {
+                // Found a triangular face. Return this edge.
+                return fEdges[edgeI];
+            }
+        }
+    }
+
+    // This bit should never happen.
+    FatalErrorIn
+    (
+        "inline label dynamicTopoFvMesh::getTriBoundaryEdge"
+        "(const label fIndex) const"
+    )
+        << "Cannot find a triangular face bordering face: "
+        << fIndex << " :: " << faces_[fIndex]
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+// Return length-scale at an face-location in the mesh [2D]
+inline scalar dynamicTopoFvMesh::faceLengthScale
+(
+    const label fIndex
+) const
+{
+    // Reset the scale first
+    scalar scale = 0.0;
+
+    label facePatch = whichPatch(fIndex);
+
+    // Determine whether the face is internal
+    if (facePatch < 0)
+    {
+#       ifdef FULLDEBUG
+        // Check whether neighbour is valid
+        if (neighbour_[fIndex] == -1)
+        {
+            FatalErrorIn
+            (
+                "inline scalar dynamicTopoFvMesh::faceLengthScale"
+                "(const label fIndex) const"
+            )
+                << nl << "Face: " << fIndex
+                << ": " << faces_[fIndex]
+                << " is not internal."
+                << abort(FatalError);
+        }
+#       endif
+
+        scale =
+        (
+            0.5 *
+            (
+                lengthScale_[owner_[fIndex]]
+              + lengthScale_[neighbour_[fIndex]]
+            )
+        );
+    }
+    else
+    {
+        // Fetch the fixed-length scale
+        scale = lengthEstimator().fixedLengthScale(fIndex, facePatch);
+
+        // If this is a floating face, pick the owner length-scale
+        if (lengthEstimator().isFreePatch(facePatch))
+        {
+            scale = lengthScale_[owner_[fIndex]];
+        }
+
+        // If proximity-based refinement is requested,
+        // test the proximity to the nearest non-neighbour.
+        if (lengthEstimator().isProximityPatch(facePatch))
+        {
+            label proximityFace = -1;
+
+            // Perform a proximity-check.
+            scalar distance = testProximity(fIndex, proximityFace);
+
+            if (debug > 3 && self() == 0)
+            {
+                if
+                (
+                    (proximityFace > -1) &&
+                    ((distance / 5.0) < scale)
+                )
+                {
+                    Info << " Closest opposing face detected for face: " << nl
+                         << '\t' << fIndex
+                         << " :: " << faces_[fIndex]
+                         << " was face:\n"
+                         << '\t' << proximityFace
+                         << " :: " << polyMesh::faces()[proximityFace] << nl
+                         << " with distance: " << distance
+                         << endl;
+                }
+            }
+
+            scale =
+            (
+                Foam::min
+                (
+                    scale,
+                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
+                )
+            );
+        }
+
+        // Limit scales if necessary
+        lengthEstimator().limitScale(scale);
+    }
+
+    return scale;
+}
+
+
+// Compute length-scale at an edge-location in the mesh [3D]
+inline scalar dynamicTopoFvMesh::edgeLengthScale
+(
+    const label eIndex
+) const
+{
+    // Reset the scale first
+    scalar scale = 0.0;
+
+    const labelList& eFaces = edgeFaces_[eIndex];
+
+    label edgePatch = whichEdgePatch(eIndex);
+
+    // Determine whether the edge is internal
+    if (edgePatch < 0)
+    {
+        forAll(eFaces, faceI)
+        {
+#           ifdef FULLDEBUG
+            // Check whether neighbour is valid
+            if (neighbour_[eFaces[faceI]] == -1)
+            {
+                FatalErrorIn
+                (
+                    "inline scalar dynamicTopoFvMesh::edgeLengthScale"
+                    "(const label eIndex) const"
+                )
+                    << nl << "Face: " << eFaces[faceI]
+                    << ": " << faces_[eFaces[faceI]]
+                    << " is not internal, while edge: "
+                    << eIndex << ": " << edges_[eIndex] << " is."
+                    << abort(FatalError);
+            }
+#           endif
+
+            scale += lengthScale_[owner_[eFaces[faceI]]];
+            scale += lengthScale_[neighbour_[eFaces[faceI]]];
+        }
+
+        scale /= (2.0*eFaces.size());
+    }
+    else
+    {
+        // Search for boundary faces, and average their scale
+        forAll(eFaces, faceI)
+        {
+            if (neighbour_[eFaces[faceI]] == -1)
+            {
+                scale +=
+                (
+                    lengthEstimator().fixedLengthScale
+                    (
+                        eFaces[faceI],
+                        edgePatch
+                    )
+                );
+            }
+        }
+
+        scale *= 0.5;
+
+        // If proximity-based refinement is requested,
+        // test the proximity to the nearest non-neighbour.
+        if (lengthEstimator().isProximityPatch(edgePatch))
+        {
+            label proximityFace = -1;
+
+            // Perform a proximity-check.
+            scalar distance = testProximity(eIndex, proximityFace);
+
+            if (debug > 3 && self() == 0)
+            {
+                if
+                (
+                    (proximityFace > -1) &&
+                    ((distance / 5.0) < scale)
+                )
+                {
+                    Info << " Closest opposing face detected for edge: " << nl
+                         << '\t' << eIndex
+                         << " :: " << edges_[eIndex]
+                         << " was face:\n"
+                         << '\t' << proximityFace
+                         << " :: " << polyMesh::faces()[proximityFace] << nl
+                         << " with distance: " << distance
+                         << endl;
+                }
+            }
+
+            scale =
+            (
+                Foam::min
+                (
+                    scale,
+                    ((distance / 3.0) - SMALL)/lengthEstimator().ratioMax()
+                )
+            );
+        }
+
+        // If curvature-based refinement is requested,
+        // test the variation in face-normal directions.
+        if (lengthEstimator().isCurvaturePatch(edgePatch))
+        {
+            // Obtain face-normals for both faces.
+            label count = 0;
+            FixedList<vector, 2> fNorm;
+
+            forAll(eFaces, faceI)
+            {
+                if (neighbour_[eFaces[faceI]] == -1)
+                {
+                    // Obtain the normal.
+                    meshOps::faceNormal
+                    (
+                        faces_[eFaces[faceI]],
+                        points_,
+                        fNorm[count]
+                    );
+
+                    // Normalize it.
+                    fNorm[count] /= mag(fNorm[count]);
+
+                    count++;
+                }
+            }
+
+            scalar deviation = (fNorm[0] & fNorm[1]);
+            scalar refDeviation = lengthEstimator().curvatureDeviation();
+
+            if (mag(deviation) < refDeviation)
+            {
+                // Fetch the edge
+                const edge& edgeToCheck = edges_[eIndex];
+
+                // Get the edge-length.
+                scalar length =
+                (
+                    linePointRef
+                    (
+                        points_[edgeToCheck.start()],
+                        points_[edgeToCheck.end()]
+                    ).mag()
+                );
+
+                if (debug > 3 && self() == 0)
+                {
+                    Info << "Deviation: " << deviation << nl
+                         << "curvatureDeviation: " << refDeviation
+                         << ", Edge: " << eIndex << ", Length: " << length
+                         << ", Scale: " << scale << nl
+                         << " Half-length: " << (0.5*length) << nl
+                         << " MinRatio: "
+                         << (lengthEstimator().ratioMin()*scale)
+                         << endl;
+                }
+
+                scale =
+                (
+                    Foam::min
+                    (
+                        scale,
+                        ((length - SMALL)/lengthEstimator().ratioMax())
+                    )
+                );
+            }
+        }
+
+        // Limit scales if necessary
+        lengthEstimator().limitScale(scale);
+    }
+
+    return scale;
+}
+
+
+// Check for edge bisection
+inline bool dynamicTopoFvMesh::checkBisection
+(
+    const label index
+) const
+{
+    scalar length = 0.0, scale = 0.0;
+
+    if (twoDMesh_)
+    {
+        // Fetch the edge
+        const edge& edgeToCheck = edges_[getTriBoundaryEdge(index)];
+
+        // Measure the boundary edge-length of the face in question
+        length =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck.start()],
+                points_[edgeToCheck.end()]
+            ).mag()
+        );
+
+        // Determine the length-scale at this face
+        scale = faceLengthScale(index);
+    }
+    else
+    {
+        // Fetch the edge
+        const edge& edgeToCheck = edges_[index];
+
+        // Measure the edge-length
+        length =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck.start()],
+                points_[edgeToCheck.end()]
+            ).mag()
+        );
+
+        // Determine the length-scale at this point in the mesh
+        scale = edgeLengthScale(index);
+    }
+
+    if (length > lengthEstimator().ratioMax() * scale)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Check for edge collapse
+inline bool dynamicTopoFvMesh::checkCollapse
+(
+    const label index
+) const
+{
+    scalar length = 0.0, scale = 0.0;
+
+    if (twoDMesh_)
+    {
+        // Fetch the edge
+        const edge& edgeToCheck = edges_[getTriBoundaryEdge(index)];
+
+        // Measure the boundary edge-length of the face in question
+        length =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck.start()],
+                points_[edgeToCheck.end()]
+            ).mag()
+        );
+
+        // Determine the length-scale at this face
+        scale = faceLengthScale(index);
+    }
+    else
+    {
+        // Fetch the edge
+        const edge& edgeToCheck = edges_[index];
+
+        // Measure the edge-length
+        length =
+        (
+            linePointRef
+            (
+                points_[edgeToCheck.start()],
+                points_[edgeToCheck.end()]
+            ).mag()
+        );
+
+        // Determine the length-scale at this point in the mesh
+        scale = edgeLengthScale(index);
+    }
+
+    if (length < lengthEstimator().ratioMin() * scale)
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+// Return the entity stack
+inline Stack& dynamicTopoFvMesh::stack
+(
+    const label threadID
+)
+{
+    return entityStack_[threadID];
+}
+
+
+// Return the integer ID for a given thread
+// Return zero for single-threaded operation
+inline label dynamicTopoFvMesh::self() const
+{
+    if (threader_->multiThreaded())
+    {
+        for (label i = 1; i <= threader_->getNumThreads(); i++)
+        {
+            if (handlerPtr_[i].self())
+            {
+                return i;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+// Initialize edge-stacks
+inline void dynamicTopoFvMesh::initStacks
+(
+    const labelHashSet& entities
+)
+{
+    forAll(entityStack_, stackI)
+    {
+        entityStack_[stackI].clear();
+    }
+
+    // Prepare a filling sequence based on threading operation
+    label tIndex = 0;
+    labelList tID(threader().getNumThreads());
+
+    if (threader_->multiThreaded())
+    {
+        forAll(tID, tI)
+        {
+            tID[tI] = (tI + 1);
+        }
+    }
+    else
+    {
+        tID = 0;
+    }
+
+    if (twoDMesh_)
+    {
+        forAll(faces_, faceI)
+        {
+            if (faces_[faceI].size() == 4)
+            {
+                stack(tID[tIndex]).insert(faceI);
+
+                tIndex = tID.fcIndex(tIndex);
+            }
+        }
+    }
+    else
+    {
+        forAll(edges_, edgeI)
+        {
+            if (edgeFaces_[edgeI].size())
+            {
+                stack(tID[tIndex]).insert(edgeI);
+
+                tIndex = tID.fcIndex(tIndex);
+            }
+        }
+    }
+}
+
+
+// Method to determine the old boundary patch index for a given face
+// Similar to the polyBoundaryMesh routine, but works on local information
+inline label dynamicTopoFvMesh::whichPatch
+(
+    const label index
+) const
+{
+    if (index < nOldInternalFaces_)
+    {
+        return -1;
+    }
+
+    for (label i = 0; i < boundaryMesh().size(); i++)
+    {
+        if
+        (
+            index >= oldPatchStarts_[i]
+         && index < oldPatchStarts_[i] + oldPatchSizes_[i]
+        )
+        {
+            return i;
+        }
+    }
+
+    // If not in any of the above, it's possible that the face was added
+    // at the end of the list. Check addedFacePatches_ for the patch info
+    if (addedFacePatches_.found(index))
+    {
+        return addedFacePatches_[index];
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "label dynamicTopoFvMesh::whichPatch"
+            "(const label index) const"
+        )
+            << "Cannot find patch information for face index: "
+            << index << nl
+            << " It appears that face ordering is"
+            << " inconsistent with patch information." << nl
+            << " Mesh info: " << nl
+            << "    nOldInternalFaces: " << nOldInternalFaces_ << nl
+            << "    oldPatchStarts: " << oldPatchStarts_ << nl
+            << "    oldPatchSizes: " << oldPatchSizes_ << nl
+            << abort(FatalError);
+    }
+
+    return -2;
+}
+
+
+// Method to determine the old boundary patch index for a given edge
+inline label dynamicTopoFvMesh::whichEdgePatch
+(
+    const label index
+) const
+{
+    if (index < nOldInternalEdges_)
+    {
+        return -1;
+    }
+
+    for (label i = 0; i < boundaryMesh().size(); i++)
+    {
+        if
+        (
+            index >= oldEdgePatchStarts_[i]
+         && index < oldEdgePatchStarts_[i] + oldEdgePatchSizes_[i]
+        )
+        {
+            return i;
+        }
+    }
+
+    // If not in any of the above, it's possible that the edge was added
+    // at the end of the list. Check addedEdgePatches_ for the patch info
+    if (addedEdgePatches_.found(index))
+    {
+        return addedEdgePatches_[index];
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "label dynamicTopoFvMesh::whichEdgePatch"
+            "(const label index) const"
+        )
+            << "Cannot find patch information for edge index: "
+            << index << nl
+            << " It appears that edge ordering is"
+            << " inconsistent with patch information." << nl
+            << " Mesh info: " << nl
+            << "    nOldInternalEdges: " << nOldInternalEdges_ << nl
+            << "    oldEdgePatchStarts: " << oldEdgePatchStarts_ << nl
+            << "    oldEdgePatchSizes: " << oldEdgePatchSizes_ << nl
+            << abort(FatalError);
+    }
+
+    return -2;
+}
+
+
+// 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
+{
+    if (type < statistics_.size())
+    {
+        return statistics_[type];
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "inline label dynamicTopoFvMesh::status"
+            "(const label type) const"
+        )
+            << " Unknown type: " << type << nl
+            << abort(FatalError);
+    }
+
+    return 0;
+}
+
+
+// Set a particular face index as flipped.
+inline void dynamicTopoFvMesh::setFlip(const label fIndex)
+{
+    if (fIndex < nOldFaces_)
+    {
+        if (flipFaces_.found(fIndex))
+        {
+            flipFaces_.erase(fIndex);
+        }
+        else
+        {
+            flipFaces_.insert(fIndex);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
new file mode 100644
index 000000000..b562a6c53
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshMapping.C
@@ -0,0 +1,405 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    dynamicTopoFvMesh
+
+Description
+    Functions specific to conservative mapping
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "dynamicTopoFvMesh.H"
+
+#include "meshOps.H"
+#include "IOmanip.H"
+#include "triFace.H"
+#include "objectMap.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Compute mapping weights for modified entities
+void dynamicTopoFvMesh::computeMapping
+(
+    const scalar matchTol,
+    const bool skipMapping,
+    const label faceStart,
+    const label faceSize,
+    const label cellStart,
+    const label cellSize
+)
+{
+
+}
+
+
+// Static equivalent for multiThreading
+void dynamicTopoFvMesh::computeMappingThread(void *argument)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::START);
+    }
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Recast the pointers for the argument
+    scalar& matchTol  = *(static_cast<scalar*>(thread->operator()(0)));
+    bool& skipMapping = *(static_cast<bool*>(thread->operator()(1)));
+    label& faceStart  = *(static_cast<label*>(thread->operator()(2)));
+    label& faceSize   = *(static_cast<label*>(thread->operator()(3)));
+    label& cellStart  = *(static_cast<label*>(thread->operator()(4)));
+    label& cellSize   = *(static_cast<label*>(thread->operator()(5)));
+
+    // Now calculate addressing
+    mesh.computeMapping
+    (
+        matchTol,
+        skipMapping,
+        faceStart, faceSize,
+        cellStart, cellSize
+    );
+
+    if (thread->slave())
+    {
+        thread->sendSignal(meshHandler::STOP);
+    }
+}
+
+
+// Routine to invoke threaded mapping
+void dynamicTopoFvMesh::threadedMapping
+(
+    scalar matchTol,
+    bool skipMapping
+)
+{
+    label nThreads = threader_->getNumThreads();
+
+    // If mapping is being skipped, issue a warning.
+    if (skipMapping)
+    {
+        Info << " *** Mapping is being skipped *** " << endl;
+    }
+
+    // Check if single-threaded
+    if (nThreads == 1)
+    {
+        computeMapping
+        (
+            matchTol,
+            skipMapping,
+            0, facesFromFaces_.size(),
+            0, cellsFromCells_.size()
+        );
+
+        return;
+    }
+
+    // Set one handler per thread
+    PtrList<meshHandler> hdl(nThreads);
+
+    forAll(hdl, i)
+    {
+        hdl.set(i, new meshHandler(*this, threader()));
+    }
+
+    // Simple load-balancing scheme
+    FixedList<label, 2> index(-1);
+    FixedList<labelList, 2> tStarts(labelList(nThreads, 0));
+    FixedList<labelList, 2> tSizes(labelList(nThreads, 0));
+
+    index[0] = facesFromFaces_.size();
+    index[1] = cellsFromCells_.size();
+
+    if (debug > 2)
+    {
+        Info << " Mapping Faces: " << index[0] << endl;
+        Info << " Mapping Cells: " << index[1] << endl;
+    }
+
+    forAll(index, indexI)
+    {
+        label j = 0, total = 0;
+
+        while (index[indexI]--)
+        {
+            tSizes[indexI][(j = tSizes[indexI].fcIndex(j))]++;
+        }
+
+        for (label i = 1; i < tStarts[indexI].size(); i++)
+        {
+            tStarts[indexI][i] = tSizes[indexI][i-1] + total;
+
+            total += tSizes[indexI][i-1];
+        }
+
+        if (debug > 2)
+        {
+            Info << " Load starts: " << tStarts[indexI] << endl;
+            Info << " Load sizes: " << tSizes[indexI] << endl;
+        }
+    }
+
+    // Set the argument list for each thread
+    forAll(hdl, i)
+    {
+        // Size up the argument list
+        hdl[i].setSize(6);
+
+        // Set match tolerance
+        hdl[i].set(0, &matchTol);
+
+        // Set the skipMapping flag
+        hdl[i].set(1, &skipMapping);
+
+        // Set the start/size indices
+        hdl[i].set(2, &(tStarts[0][i]));
+        hdl[i].set(3, &(tSizes[0][i]));
+        hdl[i].set(4, &(tStarts[1][i]));
+        hdl[i].set(5, &(tSizes[1][i]));
+    }
+
+    // Prior to multi-threaded operation,
+    // force calculation of demand-driven data.
+    polyMesh::cells();
+    primitiveMesh::cellCells();
+
+    const polyBoundaryMesh& boundary = boundaryMesh();
+
+    forAll(boundary, patchI)
+    {
+        boundary[patchI].faceFaces();
+    }
+
+    // Execute threads in linear sequence
+    executeThreads(identity(nThreads), hdl, &computeMappingThread);
+}
+
+
+// Set fill-in mapping information for a particular cell
+void dynamicTopoFvMesh::setCellMapping
+(
+    const label cIndex,
+    const labelList& mapCells,
+    bool addEntry
+)
+{
+    if (addEntry)
+    {
+        if (debug > 3)
+        {
+            Info << "Inserting mapping cell: " << cIndex << nl
+                 << " mapCells: " << mapCells
+                 << endl;
+        }
+
+        // Insert index into the list, and overwrite if necessary
+        label index = -1;
+
+        forAll(cellsFromCells_, indexI)
+        {
+            if (cellsFromCells_[indexI].index() == cIndex)
+            {
+                index = indexI;
+                break;
+            }
+        }
+
+        if (index == -1)
+        {
+            meshOps::sizeUpList
+            (
+                objectMap(cIndex, labelList(0)),
+                cellsFromCells_
+            );
+        }
+        else
+        {
+            cellsFromCells_[index].masterObjects() = labelList(0);
+        }
+    }
+
+    // Update cell-parents information
+    labelHashSet masterCells;
+
+    forAll(mapCells, cellI)
+    {
+        if (mapCells[cellI] < 0)
+        {
+            continue;
+        }
+
+        if (mapCells[cellI] < nOldCells_)
+        {
+            masterCells.insert(mapCells[cellI]);
+        }
+        else
+        if (cellParents_.found(mapCells[cellI]))
+        {
+            const labelList& nParents = cellParents_[mapCells[cellI]];
+
+            forAll(nParents, cI)
+            {
+                masterCells.insert(nParents[cI]);
+            }
+        }
+    }
+
+    cellParents_.set(cIndex, masterCells.toc());
+}
+
+
+// Set fill-in mapping information for a particular face
+void dynamicTopoFvMesh::setFaceMapping
+(
+    const label fIndex,
+    const labelList& mapFaces
+)
+{
+    label patch = whichPatch(fIndex);
+
+    if (debug > 3)
+    {
+        Info << "Inserting mapping face: " << fIndex << nl
+             << " patch: " << patch << nl
+             << " mapFaces: " << mapFaces
+             << endl;
+    }
+
+    bool foundError = false;
+
+    // Check to ensure that internal faces are not mapped
+    // from any faces in the mesh
+    if (patch == -1 && mapFaces.size())
+    {
+        foundError = true;
+    }
+
+    // Check to ensure that boundary faces map
+    // only from other faces on the same patch
+    if (patch > -1 && mapFaces.empty())
+    {
+        foundError = true;
+    }
+
+    if (foundError)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "void dynamicTopoFvMesh::setFaceMapping\n"
+            "(\n"
+            "    const label fIndex,\n"
+            "    const labelList& mapFaces\n"
+            ")"
+        )
+            << nl << " Incompatible mapping. " << nl
+            << "  Possible reasons: " << nl
+            << "    1. No mapping specified for a boundary face; " << nl
+            << "    2. Mapping specified for an internal face, " << nl
+            << "       when none was expected." << nl << nl
+            << " Face: " << fIndex << nl
+            << " Patch: " << patch << nl
+            << " Owner: " << owner_[fIndex] << nl
+            << " Neighbour: " << neighbour_[fIndex] << nl
+            << " mapFaces: " << mapFaces << nl
+            << abort(FatalError);
+    }
+
+    // Insert addressing into the list, and overwrite if necessary
+    label index = -1;
+
+    forAll(facesFromFaces_, indexI)
+    {
+        if (facesFromFaces_[indexI].index() == fIndex)
+        {
+            index = indexI;
+            break;
+        }
+    }
+
+    if (index == -1)
+    {
+        meshOps::sizeUpList
+        (
+            objectMap(fIndex, labelList(0)),
+            facesFromFaces_
+        );
+    }
+    else
+    {
+        facesFromFaces_[index].masterObjects() = labelList(0);
+    }
+
+    // For internal faces, set dummy maps / weights, and bail out
+    if (patch == -1)
+    {
+        return;
+    }
+
+    // Update face-parents information
+    labelHashSet masterFaces;
+
+    forAll(mapFaces, faceI)
+    {
+        if (mapFaces[faceI] < 0)
+        {
+            continue;
+        }
+
+        if (mapFaces[faceI] < nOldFaces_)
+        {
+            masterFaces.insert(mapFaces[faceI]);
+        }
+        else
+        if (faceParents_.found(mapFaces[faceI]))
+        {
+            const labelList& nParents = faceParents_[mapFaces[faceI]];
+
+            forAll(nParents, fI)
+            {
+                masterFaces.insert(nParents[fI]);
+            }
+        }
+    }
+
+    faceParents_.set(fIndex, masterFaces.toc());
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
new file mode 100644
index 000000000..b309283b0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMeshReOrder.C
@@ -0,0 +1,1771 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "objectMap.H"
+#include "dynamicTopoFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Reorder points after a topology change
+void dynamicTopoFvMesh::reOrderPoints
+(
+    pointField& points,
+    pointField& preMotionPoints,
+    labelListList& pointZoneMap,
+    bool threaded
+)
+{
+    // *** Point renumbering *** //
+    // If points were deleted during topology change, the numerical order ceases
+    // to be continuous. Loop through all points and renumber sequentially.
+
+    if (debug)
+    {
+        if (threaded)
+        {
+            Info << "Thread: " << self() << ": ";
+        }
+
+        Info << "ReOrdering points..." << flush;
+    }
+
+    // Allocate for the mapping information
+    pointMap_.setSize(nPoints_, -1);
+
+    label pointInOrder = 0;
+
+    addedPointRenumbering_.clear();
+
+    for (label pointI = 0; pointI < nOldPoints_; pointI++)
+    {
+        // Check if this is a deleted point
+        if (reversePointMap_[pointI] == -1)
+        {
+            continue;
+        }
+
+        // Update the point info
+        points[pointInOrder] = points_[pointI];
+        preMotionPoints[pointInOrder] = oldPoints_[pointI];
+
+        // Update maps
+        pointMap_[pointInOrder]  = pointI;
+        reversePointMap_[pointI] = pointInOrder;
+
+        // Update the counter
+        pointInOrder++;
+    }
+
+    for (label pointI = nOldPoints_; pointI < points_.size(); pointI++)
+    {
+        // Was this point removed after addition?
+        if (deletedPoints_.found(pointI))
+        {
+            continue;
+        }
+
+        // Update the point info
+        points[pointInOrder] = points_[pointI];
+        preMotionPoints[pointInOrder] = oldPoints_[pointI];
+
+        // Put inserted points in a seperate hashSet
+        addedPointRenumbering_.insert(pointI, pointInOrder);
+
+        // Update the counter
+        pointInOrder++;
+    }
+
+    // Now that we're done preparing the point maps, unlock the point mutex
+    if (threaded)
+    {
+        entityMutex_[0].unlock();
+    }
+
+    // Final check to ensure everything went okay
+    if (pointInOrder != nPoints_)
+    {
+        FatalErrorIn("dynamicTopoFvMesh::reOrderPoints()") << nl
+            << " Algorithm did not visit every point in the mesh."
+            << " Something's messed up." << nl
+            << abort(FatalError);
+    }
+
+    // Wipe out pointsFromPoints, since this is not
+    // really used in this context for mapping.
+    pointsFromPoints_.clear();
+
+    // Renumber all maps.
+    forAll(pointsFromPoints_, indexI)
+    {
+        objectMap& thisMap = pointsFromPoints_[indexI];
+
+        if (thisMap.index() < nOldPoints_)
+        {
+            thisMap.index() = reversePointMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedPointRenumbering_[thisMap.index()];
+        }
+    }
+
+    // Prepare the pointZoneMap
+    pointZoneMesh& pointZones = polyMesh::pointZones();
+
+    labelListList newPointZoneAddr(pointZones.size());
+    labelList nPointsInZone(pointZones.size(), 0);
+
+    // Prepare zone maps.
+    forAll(pointZones, pzI)
+    {
+        // Get the list of old points
+        const labelList& oldAddr = pointZones[pzI];
+
+        label& curNPoints = nPointsInZone[pzI];
+
+        // First count the actual number of points in each zone.
+        forAll(oldAddr, pointI)
+        {
+            // Was this zone point deleted? Don't count it.
+            if (reversePointMap_[oldAddr[pointI]] != -1)
+            {
+                curNPoints++;
+            }
+        }
+
+        // Check for added points as well
+        forAllIter(Map<label>, addedPointZones_, pIter)
+        {
+            if (pIter() == pzI)
+            {
+                curNPoints++;
+            }
+        }
+
+        label pIndex = 0;
+        labelList& newAddr = newPointZoneAddr[pzI];
+
+        // Set the sizes first
+        newAddr.setSize(curNPoints);
+        pointZoneMap[pzI].setSize(curNPoints, -1);
+
+        // Add existing zone points which have been renumbered.
+        forAll(oldAddr, pointI)
+        {
+            if (reversePointMap_[oldAddr[pointI]] != -1)
+            {
+                pointZoneMap[pzI][pIndex] = oldAddr[pointI];
+                newAddr[pIndex] = reversePointMap_[oldAddr[pointI]];
+                pIndex++;
+            }
+        }
+
+        // Next, add the newly added zone points.
+        forAllIter(Map<label>, addedPointZones_, pIter)
+        {
+            if (pIter() == pzI)
+            {
+                newAddr[pIndex++] = addedPointRenumbering_[pIter.key()];
+            }
+        }
+
+        // Finally, assign addressing to this zone.
+        pointZones[pzI] = newPointZoneAddr[pzI];
+    }
+
+    // Reset all zones
+    pointZones.updateMesh();
+
+    // Clear local point copies
+    points_.clear();
+    oldPoints_.clear();
+
+    // Set values
+    points_ = points;
+    oldPoints_ = preMotionPoints;
+
+    if (debug)
+    {
+        Info << "Done." << endl;
+    }
+}
+
+
+// Static equivalent for multi-threading
+void dynamicTopoFvMesh::reOrderPointsThread
+(
+    void *argument
+)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Lock the point mutex first
+    mesh.entityMutex(0).lock();
+
+    // Signal the calling thread
+    thread->sendSignal(meshHandler::START);
+
+    // Recast the pointers for the reOrderPoints argument
+    pointField& points =
+    (
+        *(static_cast<pointField*>(thread->operator()(0)))
+    );
+
+    pointField& preMotionPoints =
+    (
+        *(static_cast<pointField*>(thread->operator()(1)))
+    );
+
+    labelListList& pointZoneMap =
+    (
+        *(static_cast<labelListList*>(thread->operator()(2)))
+    );
+
+    // Reorder the points
+    mesh.reOrderPoints(points, preMotionPoints, pointZoneMap, true);
+}
+
+
+// Reorder edges after a topology change
+void dynamicTopoFvMesh::reOrderEdges
+(
+    edgeList& edges,
+    labelListList& edgeFaces,
+    labelListList& faceEdges,
+    bool threaded
+)
+{
+    // *** Edge renumbering *** //
+    // If edges were deleted during topology change, the numerical order ceases
+    // to be continuous. Edges are added to respective internal/boundary patches
+
+    if (debug)
+    {
+        if (threaded)
+        {
+            Info << "Thread: " << self() << ": ";
+        }
+
+        Info << "ReOrdering edges..." << flush;
+    }
+
+    // Allocate for mapping information
+    edgeMap_.setSize(nEdges_, -1);
+
+    label edgeInOrder = 0, allEdges = edges_.size();
+    edgeList oldEdges(allEdges);
+    labelListList oldEdgeFaces(allEdges);
+    labelListList oldEdgePoints(allEdges);
+
+    addedEdgeRenumbering_.clear();
+    Map<label> addedEdgeReverseRenumbering;
+
+    // Transfer old edge-based lists, and clear them
+    forAll(edges_, edgeI)
+    {
+        oldEdges[edgeI] = edges_[edgeI];
+        oldEdgeFaces[edgeI].transfer(edgeFaces_[edgeI]);
+    }
+
+    edges_.setSize(nEdges_); edgeFaces_.setSize(nEdges_);
+
+    if (!twoDMesh_)
+    {
+        forAll(edgePoints_, edgeI)
+        {
+            oldEdgePoints[edgeI].transfer(edgePoints_[edgeI]);
+        }
+
+        edgePoints_.setSize(nEdges_);
+    }
+
+    // Keep track of inserted boundary edge indices
+    labelList boundaryPatchIndices(edgePatchStarts_);
+
+    // Loop through all edges and add internal ones first
+    forAll(oldEdges, edgeI)
+    {
+        // Ensure that we're adding valid edges
+        if (oldEdgeFaces[edgeI].empty())
+        {
+            continue;
+        }
+
+        // Determine which patch this edge belongs to
+        label patch = whichEdgePatch(edgeI);
+
+        // Update maps for boundary edges. Edge insertion for
+        // boundaries will be done after internal edges.
+        if (patch >= 0)
+        {
+            label bEdgeIndex = boundaryPatchIndices[patch]++;
+
+            // Update the maps
+            if (edgeI < nOldEdges_)
+            {
+                edgeMap_[bEdgeIndex] = edgeI;
+                reverseEdgeMap_[edgeI] = bEdgeIndex;
+            }
+            else
+            {
+                addedEdgeRenumbering_.insert(edgeI, bEdgeIndex);
+                addedEdgeReverseRenumbering.insert(bEdgeIndex, edgeI);
+
+                edgeMap_[bEdgeIndex] = -1;
+            }
+        }
+        else
+        {
+            // Obtain references
+            edge& thisEdge = oldEdges[edgeI];
+            labelList& thisEF = oldEdgeFaces[edgeI];
+
+            // Renumber internal edges and add normally.
+            if (edgeI < nOldEdges_)
+            {
+                edgeMap_[edgeInOrder] = edgeI;
+                reverseEdgeMap_[edgeI] = edgeInOrder;
+            }
+            else
+            {
+                addedEdgeRenumbering_.insert(edgeI, edgeInOrder);
+            }
+
+            // Insert entities into local lists...
+            edges_[edgeInOrder] = thisEdge;
+            edgeFaces_[edgeInOrder] = thisEF;
+
+            // Insert entities into mesh-reset lists
+            edges[edgeInOrder] = thisEdge;
+            edgeFaces[edgeInOrder].transfer(thisEF);
+
+            if (!twoDMesh_)
+            {
+                edgePoints_[edgeInOrder].transfer(oldEdgePoints[edgeI]);
+            }
+
+            edgeInOrder++;
+        }
+    }
+
+    // All internal edges have been inserted. Now insert boundary edges.
+    label oldIndex;
+
+    for(label i = nInternalEdges_; i < nEdges_; i++)
+    {
+        if (edgeMap_[i] == -1)
+        {
+            // This boundary edge was added during the topology change
+            oldIndex = addedEdgeReverseRenumbering[i];
+        }
+        else
+        {
+            oldIndex = edgeMap_[i];
+        }
+
+        // Insert entities into local Lists...
+        edges_[edgeInOrder] = oldEdges[oldIndex];
+        edgeFaces_[edgeInOrder] = oldEdgeFaces[oldIndex];
+
+        // Insert entities into mesh-reset lists
+        edges[edgeInOrder] = oldEdges[oldIndex];
+        edgeFaces[edgeInOrder].transfer(oldEdgeFaces[oldIndex]);
+
+        if (!twoDMesh_)
+        {
+            edgePoints_[edgeInOrder].transfer(oldEdgePoints[oldIndex]);
+        }
+
+        edgeInOrder++;
+    }
+
+    // Now that we're done with edges, unlock it
+    if (threaded)
+    {
+        entityMutex_[1].unlock();
+    }
+
+    // Final check to ensure everything went okay
+    if (edgeInOrder != nEdges_)
+    {
+        FatalErrorIn("dynamicTopoFvMesh::reOrderEdges()") << nl
+                << " Algorithm did not visit every edge in the mesh."
+                << " Something's messed up." << nl
+                << abort(FatalError);
+    }
+
+    // Renumber all edges / edgePoints with updated point information
+    label pIndex = -1;
+
+    if (threaded)
+    {
+        entityMutex_[0].lock();
+    }
+
+    forAll(edges_, edgeI)
+    {
+        // Obtain references
+        edge& thisEdge = edges_[edgeI];
+        edge& thisREdge = edges[edgeI];
+
+        // Renumber edges
+        if (thisEdge[0] < nOldPoints_)
+        {
+            pIndex = reversePointMap_[thisEdge[0]];
+        }
+        else
+        {
+            pIndex = addedPointRenumbering_[thisEdge[0]];
+        }
+
+        thisEdge[0] = pIndex;
+        thisREdge[0] = pIndex;
+
+        if (thisEdge[1] < nOldPoints_)
+        {
+            pIndex = reversePointMap_[thisEdge[1]];
+        }
+        else
+        {
+            pIndex = addedPointRenumbering_[thisEdge[1]];
+        }
+
+        thisEdge[1] = pIndex;
+        thisREdge[1] = pIndex;
+
+        // Renumber edgePoints
+        if (!twoDMesh_)
+        {
+            labelList& ePoints = edgePoints_[edgeI];
+
+            forAll(ePoints, pointI)
+            {
+                if (ePoints[pointI] < nOldPoints_)
+                {
+                    ePoints[pointI] = reversePointMap_[ePoints[pointI]];
+                }
+                else
+                {
+                    ePoints[pointI] = addedPointRenumbering_[ePoints[pointI]];
+                }
+            }
+        }
+    }
+
+    if (threaded)
+    {
+        entityMutex_[0].unlock();
+    }
+
+    // Renumber all faceEdges
+    label eIndex = -1;
+
+    if (threaded)
+    {
+        entityMutex_[2].lock();
+    }
+
+    forAll(faceEdges_, faceI)
+    {
+        // Obtain references
+        labelList& fEdges = faceEdges_[faceI];
+        labelList& rfEdges = faceEdges[faceI];
+
+        forAll(fEdges, edgeI)
+        {
+            if (fEdges[edgeI] < nOldEdges_)
+            {
+                eIndex = reverseEdgeMap_[fEdges[edgeI]];
+            }
+            else
+            {
+                eIndex = addedEdgeRenumbering_[fEdges[edgeI]];
+            }
+
+            fEdges[edgeI] = eIndex;
+            rfEdges[edgeI] = eIndex;
+        }
+    }
+
+    // Renumber all edgeFaces
+    label fIndex = -1;
+
+    forAll(edgeFaces_, edgeI)
+    {
+        // Obtain references
+        labelList& eFaces = edgeFaces_[edgeI];
+        labelList& reFaces = edgeFaces[edgeI];
+
+        // Renumber edgeFaces
+        forAll(eFaces, faceI)
+        {
+            if (eFaces[faceI] < nOldFaces_)
+            {
+                fIndex = reverseFaceMap_[eFaces[faceI]];
+            }
+            else
+            {
+                fIndex = addedFaceRenumbering_[eFaces[faceI]];
+            }
+
+            eFaces[faceI] = fIndex;
+            reFaces[faceI] = fIndex;
+        }
+    }
+
+    if (threaded)
+    {
+        entityMutex_[2].unlock();
+    }
+
+    if (!twoDMesh_)
+    {
+        // Invert edges to obtain pointEdges
+        pointEdges_ = invertManyToMany<edge, labelList>(nPoints_, edges_);
+    }
+
+    if (debug)
+    {
+        Info << "Done." << endl;
+    }
+}
+
+
+// Static equivalent for multi-threading
+void dynamicTopoFvMesh::reOrderEdgesThread
+(
+    void *argument
+)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Lock the edge mutex first
+    mesh.entityMutex(1).lock();
+
+    // Signal the calling thread
+    thread->sendSignal(meshHandler::START);
+
+    // Recast the pointers for the argument
+    edgeList& edges =
+    (
+        *(static_cast<edgeList*>(thread->operator()(0)))
+    );
+
+    labelListList& edgeFaces =
+    (
+        *(static_cast<labelListList*>(thread->operator()(1)))
+    );
+
+    labelListList& faceEdges =
+    (
+        *(static_cast<labelListList*>(thread->operator()(2)))
+    );
+
+    // Reorder the edges
+    mesh.reOrderEdges(edges, edgeFaces, faceEdges, true);
+
+    // Signal the calling thread
+    thread->sendSignal(meshHandler::STOP);
+}
+
+
+// Reorder faces in upper-triangular order after a topology change
+void dynamicTopoFvMesh::reOrderFaces
+(
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour,
+    labelListList& faceEdges,
+    labelListList& faceZoneFaceMap,
+    bool threaded
+)
+{
+    // *** Face renumbering *** //
+    // Faces have to be renumbered if any were added/deleted/modified
+    // Boundary faces are added to respective patches.
+    // Internal faces, however, have to be added in upper-triangular ordering;
+    // i.e., in the increasing order of neighbours
+
+    if (debug)
+    {
+        if (threaded)
+        {
+            Info << "Thread: " << self() << ": ";
+        }
+
+        Info << "ReOrdering faces..." << flush;
+    }
+
+    // Allocate for mapping information
+    faceMap_.setSize(nFaces_, -1);
+
+    label faceInOrder = 0, allFaces = faces_.size();
+    faceList oldFaces(allFaces);
+    labelList oldOwner(allFaces), oldNeighbour(allFaces), visited(allFaces,0);
+    labelListList oldFaceEdges(allFaces);
+
+    addedFaceRenumbering_.clear();
+    Map<label> addedFaceReverseRenumbering;
+
+    // Make a copy of the old face-based lists, and clear them
+    forAll(faces_, faceI)
+    {
+        oldFaces[faceI].transfer(faces_[faceI]);
+        oldOwner[faceI] = owner_[faceI];
+        oldNeighbour[faceI] = neighbour_[faceI];
+        oldFaceEdges[faceI].transfer(faceEdges_[faceI]);
+    }
+
+    // Renumber all faces with updated point information
+    label pIndex = -1;
+
+    if (threaded)
+    {
+        entityMutex_[0].lock();
+    }
+
+    forAll(oldFaces, faceI)
+    {
+        face& thisFace = oldFaces[faceI];
+
+        forAll(thisFace, pointI)
+        {
+            if (thisFace[pointI] < nOldPoints_)
+            {
+                pIndex = reversePointMap_[thisFace[pointI]];
+            }
+            else
+            {
+                pIndex = addedPointRenumbering_[thisFace[pointI]];
+            }
+
+            thisFace[pointI] = pIndex;
+        }
+    }
+
+    if (threaded)
+    {
+        entityMutex_[0].unlock();
+    }
+
+    // Wait for the cell mutex to become available
+    if (threaded)
+    {
+        entityMutex_[3].lock();
+    }
+
+    faces_.setSize(nFaces_);
+    owner_.setSize(nFaces_);
+    neighbour_.setSize(nFaces_);
+    faceEdges_.setSize(nFaces_);
+
+    // Mark the internal faces with -2 so that they are inserted first
+    forAll(cells_, cellI)
+    {
+        const cell& curFaces = cells_[cellI];
+
+        forAll(curFaces, faceI)
+        {
+            visited[curFaces[faceI]]--;
+        }
+    }
+
+    // Keep track of inserted boundary face indices
+    labelList boundaryPatchIndices(patchStarts_);
+
+    // Handle boundaries first. If any coupled interfaces need to be
+    // updated, they can be reshuffled after interior faces are done.
+    // Update maps for boundaries now.
+    for (label faceI = nOldInternalFaces_; faceI < allFaces; faceI++)
+    {
+        if (visited[faceI] == -1)
+        {
+            label patchID = whichPatch(faceI);
+            label bFaceIndex = boundaryPatchIndices[patchID]++;
+
+            // Update the maps
+            if (faceI < nOldFaces_)
+            {
+                faceMap_[bFaceIndex] = faceI;
+                reverseFaceMap_[faceI] = bFaceIndex;
+            }
+            else
+            {
+                addedFaceRenumbering_.insert(faceI, bFaceIndex);
+
+                addedFaceReverseRenumbering.insert(bFaceIndex, faceI);
+
+                faceMap_[bFaceIndex] = -1;
+            }
+
+            // Mark this face as visited
+            visited[faceI] = 0;
+        }
+    }
+
+    // Upper-triangular ordering of internal faces:
+
+    // Insertion cannot be done in one go as the faces need to be
+    // added into the list in the increasing order of neighbour
+    // cells.  Therefore, all neighbours will be detected first
+    // and then added in the correct order.
+    forAll(cells_, cellI)
+    {
+        // Record the neighbour cell
+        const cell& curFaces = cells_[cellI];
+
+        labelList neiCells(curFaces.size(), -1);
+
+        label nNeighbours = 0;
+
+        forAll(curFaces, faceI)
+        {
+            if (visited[curFaces[faceI]] == -2)
+            {
+                // Face is internal and gets reordered
+                label own =
+                (
+                    oldOwner[curFaces[faceI]] < nOldCells_
+                  ? reverseCellMap_[oldOwner[curFaces[faceI]]]
+                  : addedCellRenumbering_[oldOwner[curFaces[faceI]]]
+                );
+
+                label nei =
+                (
+                    oldNeighbour[curFaces[faceI]] < nOldCells_
+                  ? reverseCellMap_[oldNeighbour[curFaces[faceI]]]
+                  : addedCellRenumbering_[oldNeighbour[curFaces[faceI]]]
+                );
+
+                label smallerIndex = own < nei ? own : nei;
+                label largerIndex  = own > nei ? own : nei;
+
+                if (cellI == smallerIndex)
+                {
+                    neiCells[faceI] = largerIndex;
+                    nNeighbours++;
+                }
+            }
+        }
+
+        // Add internal faces in the increasing order of neighbours
+        for (label neiSearch = 0; neiSearch < nNeighbours; neiSearch++)
+        {
+            // Find the lowest neighbour which is still valid
+            label nextNei = -1;
+            label minNei = nCells_;
+
+            forAll(neiCells, ncI)
+            {
+                if (neiCells[ncI] > -1 && neiCells[ncI] < minNei)
+                {
+                    nextNei = ncI;
+                    minNei = neiCells[ncI];
+                }
+            }
+
+            if (nextNei > -1)
+            {
+                // Face is internal and gets reordered
+                if (curFaces[nextNei] < nOldFaces_)
+                {
+                    faceMap_[faceInOrder] = curFaces[nextNei];
+                    reverseFaceMap_[curFaces[nextNei]] = faceInOrder;
+                }
+                else
+                {
+                    addedFaceRenumbering_.insert
+                    (
+                        curFaces[nextNei],
+                        faceInOrder
+                    );
+                }
+
+                // Renumber owner/neighbour
+                label oldOwn = oldOwner[curFaces[nextNei]];
+                label oldNei = oldNeighbour[curFaces[nextNei]];
+
+                label ownerRenumber =
+                (
+                    oldOwn < nOldCells_
+                  ? reverseCellMap_[oldOwn] : addedCellRenumbering_[oldOwn]
+                );
+
+                label neighbourRenumber =
+                (
+                    oldNei < nOldCells_
+                  ? reverseCellMap_[oldNei] : addedCellRenumbering_[oldNei]
+                );
+
+                // Cell-reordering may cause flipped faces.. Correct them.
+                face& faceRenumber = oldFaces[curFaces[nextNei]];
+
+                if (neighbourRenumber < ownerRenumber)
+                {
+                    faceRenumber = faceRenumber.reverseFace();
+
+                    if (!bandWidthReduction_)
+                    {
+                        FatalErrorIn("dynamicTopoFvMesh::reOrderFaces()")
+                            << nl
+                            << " Found an improperly ordered face."
+                            << " Something's messed up." << nl
+                            << abort(FatalError);
+                    }
+
+                    setFlip(curFaces[nextNei]);
+                }
+
+                // Insert entities into local lists...
+                faces_[faceInOrder] = faceRenumber;
+                owner_[faceInOrder] = cellI;
+                neighbour_[faceInOrder] = minNei;
+                faceEdges_[faceInOrder] =
+                (
+                    oldFaceEdges[curFaces[nextNei]]
+                );
+
+                // Insert entities into mesh-reset lists
+                faces[faceInOrder].transfer(faceRenumber);
+                owner[faceInOrder] = cellI;
+                neighbour[faceInOrder] = minNei;
+                faceEdges[faceInOrder].transfer
+                (
+                    oldFaceEdges[curFaces[nextNei]]
+                );
+
+                // Stop the neighbour from being used again
+                neiCells[nextNei] = -1;
+
+                // Mark this face as visited
+                visited[curFaces[nextNei]] = 0;
+
+                faceInOrder++;
+            }
+            else
+            {
+                FatalErrorIn("dynamicTopoFvMesh::reOrderFaces()") << nl
+                    << "Error in internal face insertion" << nl
+                    << abort(FatalError);
+            }
+        }
+    }
+
+    // All internal faces have been inserted. Now insert boundary faces.
+    label oldIndex;
+
+    for (label i = nInternalFaces_; i < nFaces_; i++)
+    {
+        if (faceMap_[i] == -1)
+        {
+            // This boundary face was added during the topology change
+            oldIndex = addedFaceReverseRenumbering[i];
+        }
+        else
+        {
+            oldIndex = faceMap_[i];
+        }
+
+        // Renumber owner/neighbour
+        label ownerRenumber =
+        (
+            oldOwner[oldIndex] < nOldCells_
+          ? reverseCellMap_[oldOwner[oldIndex]]
+          : addedCellRenumbering_[oldOwner[oldIndex]]
+        );
+
+        // Insert entities into local listsLists...
+        faces_[faceInOrder] = oldFaces[oldIndex];
+        owner_[faceInOrder] = ownerRenumber;
+        neighbour_[faceInOrder] = -1;
+        faceEdges_[faceInOrder] = oldFaceEdges[oldIndex];
+
+        // Insert entities into mesh-reset lists
+        // NOTE: From OF-1.5 onwards, neighbour array
+        //       does not store -1 for boundary faces
+        faces[faceInOrder].transfer(oldFaces[oldIndex]);
+        owner[faceInOrder] = ownerRenumber;
+        faceEdges[faceInOrder].transfer(oldFaceEdges[oldIndex]);
+
+        faceInOrder++;
+    }
+
+    // Now that we're done with faces, unlock it
+    if (threaded)
+    {
+        entityMutex_[2].unlock();
+    }
+
+    // Renumber all maps.
+    forAll(facesFromPoints_, indexI)
+    {
+        objectMap& thisMap = facesFromPoints_[indexI];
+
+        if (thisMap.index() < nOldFaces_)
+        {
+            thisMap.index() = reverseFaceMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedFaceRenumbering_[thisMap.index()];
+        }
+    }
+
+    forAll(facesFromEdges_, indexI)
+    {
+        objectMap& thisMap = facesFromEdges_[indexI];
+
+        if (thisMap.index() < nOldFaces_)
+        {
+            thisMap.index() = reverseFaceMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedFaceRenumbering_[thisMap.index()];
+        }
+    }
+
+    forAll(facesFromFaces_, indexI)
+    {
+        objectMap& thisMap = facesFromFaces_[indexI];
+
+        if (thisMap.index() < nOldFaces_)
+        {
+            thisMap.index() = reverseFaceMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedFaceRenumbering_[thisMap.index()];
+        }
+    }
+
+    // Renumber all flipFaces
+    labelHashSet flipFaces;
+
+    forAllIter(labelHashSet, flipFaces_, fIter)
+    {
+        if (fIter.key() < nOldFaces_)
+        {
+            flipFaces.insert(reverseFaceMap_[fIter.key()]);
+        }
+        else
+        {
+            // Added faces cannot be flipped.
+            FatalErrorIn("dynamicTopoFvMesh::reOrderFaces()") << nl
+                << " Face: " << fIter.key()
+                << " is new, and shouldn't be flipped." << nl
+                << " nOldFaces: " << nOldFaces_
+                << abort(FatalError);
+        }
+    }
+
+    flipFaces_.transfer(flipFaces);
+
+    // Renumber all cells with updated face information
+    forAll(cells_, cellI)
+    {
+        cell& cellFaces = cells_[cellI];
+
+        forAll(cellFaces, faceI)
+        {
+            if (cellFaces[faceI] < nOldFaces_)
+            {
+                cellFaces[faceI] = reverseFaceMap_[cellFaces[faceI]];
+            }
+            else
+            {
+                cellFaces[faceI] = addedFaceRenumbering_[cellFaces[faceI]];
+            }
+        }
+    }
+
+    // Now that we're done with cells, unlock it
+    if (threaded)
+    {
+        entityMutex_[3].unlock();
+    }
+
+    // Final check to ensure everything went okay
+    if (debug > 1)
+    {
+        if (sum(visited) != 0)
+        {
+            FatalErrorIn("dynamicTopoFvMesh::reOrderFaces()") << nl
+                << " Algorithm did not visit every face in the mesh."
+                << " Something's messed up." << nl
+                << abort(FatalError);
+        }
+    }
+
+    // Prepare the faceZoneMap
+    faceZoneMesh& faceZones = polyMesh::faceZones();
+
+    labelListList newFaceZoneAddr(faceZones.size());
+    boolListList faceZoneFlipMap(faceZones.size());
+    labelList nFacesInZone(faceZones.size(), 0);
+
+    // Prepare zone maps.
+    forAll(faceZones, fzI)
+    {
+        // Get the list of old faces
+        const labelList& oldAddr = faceZones[fzI];
+
+        label& curNFaces = nFacesInZone[fzI];
+
+        // First count the actual number of faces in each zone.
+        forAll(oldAddr, faceI)
+        {
+            // Was this zone face deleted? Don't count it.
+            if (reverseFaceMap_[oldAddr[faceI]] != -1)
+            {
+                curNFaces++;
+            }
+        }
+
+        // Check for added faces as well
+        forAllIter(Map<label>, addedFaceZones_, fIter)
+        {
+            if (fIter() == fzI)
+            {
+                curNFaces++;
+            }
+        }
+
+        label fIndex = 0;
+        labelList& newAddr = newFaceZoneAddr[fzI];
+
+        // Set the sizes first
+        newAddr.setSize(curNFaces);
+        faceZoneFaceMap[fzI].setSize(curNFaces, -1);
+        faceZoneFlipMap[fzI].setSize(curNFaces, false);
+
+        // Add existing zone faces which have been renumbered.
+        forAll(oldAddr, faceI)
+        {
+            if (reverseFaceMap_[oldAddr[faceI]] != -1)
+            {
+                faceZoneFaceMap[fzI][fIndex] = oldAddr[faceI];
+                newAddr[fIndex] = reverseFaceMap_[oldAddr[faceI]];
+                fIndex++;
+            }
+        }
+
+        // Next, add the newly added zone faces.
+        forAllIter(Map<label>, addedFaceZones_, fIter)
+        {
+            if (fIter() == fzI)
+            {
+                newAddr[fIndex++] = addedFaceRenumbering_[fIter.key()];
+            }
+        }
+
+        // Finally, reset addressing for this zone.
+        faceZones[fzI].resetAddressing
+        (
+            newFaceZoneAddr[fzI],
+            faceZoneFlipMap[fzI]
+        );
+    }
+
+    // Reset all zones
+    faceZones.updateMesh();
+
+    if (debug)
+    {
+        Info << "Done." << endl;
+    }
+}
+
+
+// Static equivalent for multi-threading
+void dynamicTopoFvMesh::reOrderFacesThread
+(
+    void *argument
+)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Lock the face mutex first
+    mesh.entityMutex(2).lock();
+
+    // Signal the calling thread
+    thread->sendSignal(meshHandler::START);
+
+    // Recast the pointers for the argument
+    faceList& faces =
+    (
+        *(static_cast<faceList*>(thread->operator()(0)))
+    );
+
+    labelList& owner =
+    (
+        *(static_cast<labelList*>(thread->operator()(1)))
+    );
+
+    labelList& neighbour =
+    (
+        *(static_cast<labelList*>(thread->operator()(2)))
+    );
+
+    labelListList& faceEdges =
+    (
+        *(static_cast<labelListList*>(thread->operator()(3)))
+    );
+
+    labelListList& faceZoneFaceMap =
+    (
+        *(static_cast<labelListList*>(thread->operator()(4)))
+    );
+
+    // Reorder the faces
+    mesh.reOrderFaces
+    (
+        faces,
+        owner,
+        neighbour,
+        faceEdges,
+        faceZoneFaceMap,
+        true
+    );
+}
+
+
+// Reorder & renumber cells with bandwidth reduction after a topology change
+void dynamicTopoFvMesh::reOrderCells
+(
+    labelListList& cellZoneMap,
+    bool threaded
+)
+{
+    // *** Cell renumbering *** //
+    // If cells were deleted during topology change, the numerical order ceases
+    // to be continuous. Also, cells are always added at the end of the list by
+    // virtue of the append method. Thus, cells would now have to be
+    // reordered so that bandwidth is reduced and renumbered to be sequential.
+
+    if (debug)
+    {
+        if (threaded)
+        {
+            Info << "Thread: " << self() << ": ";
+        }
+
+        Info << "ReOrdering cells..." << flush;
+    }
+
+    // Allocate for mapping information
+    cellMap_.setSize(nCells_, -1);
+
+    label cellInOrder = 0;
+
+    addedCellRenumbering_.clear();
+
+    // Make a copy of the old cell-based lists, and clear them
+    label allCells = cells_.size();
+
+    cellList oldCells(allCells);
+
+    forAll(cells_, cellI)
+    {
+        oldCells[cellI].transfer(cells_[cellI]);
+    }
+
+    cells_.setSize(nCells_);
+
+    if (bandWidthReduction_)
+    {
+        label currentCell;
+        SLList<label> nextCell;
+        labelList ncc(allCells, 0), visited(allCells, 0);
+        labelListList cellCellAddr(allCells);
+
+        // Build a cell-cell addressing list
+        forAll(owner_, faceI)
+        {
+            if ((neighbour_[faceI] > -1) && (owner_[faceI] > -1))
+            {
+                ncc[owner_[faceI]]++;
+                ncc[neighbour_[faceI]]++;
+            }
+        }
+
+        forAll(cellCellAddr, cellI)
+        {
+            cellCellAddr[cellI].setSize(ncc[cellI]);
+
+            // Mark off deleted cells as "visited"
+            if (ncc[cellI] == 0)
+            {
+                visited[cellI] = 1;
+            }
+        }
+
+        ncc = 0;
+
+        forAll(owner_, faceI)
+        {
+            if ((owner_[faceI] > -1) && (neighbour_[faceI] > -1))
+            {
+                cellCellAddr[owner_[faceI]][ncc[owner_[faceI]]++] =
+                (
+                    neighbour_[faceI]
+                );
+
+                cellCellAddr[neighbour_[faceI]][ncc[neighbour_[faceI]]++] =
+                (
+                    owner_[faceI]
+                );
+            }
+        }
+
+        // Let's get to the "business bit" of the band-compression
+        forAll(visited, cellI)
+        {
+            // Find the first cell that has not been visited yet
+            if (visited[cellI] == 0)
+            {
+                // Use this cell as a start
+                currentCell = cellI;
+
+                nextCell.append(currentCell);
+
+                // Loop through the nextCell list. Add the first cell
+                // into the cell order if it has not already been visited
+                // and ask for its neighbours. If the neighbour in question
+                // has not been visited, add it to the end of the nextCell list
+                while (nextCell.size() > 0)
+                {
+                    currentCell = nextCell.removeHead();
+
+                    if (visited[currentCell] == 0)
+                    {
+                        // Mark as visited and update cell mapping info
+                        visited[currentCell] = 1;
+
+                        if (currentCell < nOldCells_)
+                        {
+                            cellMap_[cellInOrder] = currentCell;
+                            reverseCellMap_[currentCell] = cellInOrder;
+                        }
+                        else
+                        {
+                            addedCellRenumbering_.insert
+                            (
+                                currentCell,
+                                cellInOrder
+                            );
+                        }
+
+                        // Insert entities into local lists...
+                        cells_[cellInOrder].transfer(oldCells[currentCell]);
+
+                        cellInOrder++;
+
+                        // Find if the neighbours have been visited
+                        const labelList& neighbours = cellCellAddr[currentCell];
+
+                        forAll(neighbours, nI)
+                        {
+                            if (visited[neighbours[nI]] == 0)
+                            {
+                                // Not visited, add to the list
+                                nextCell.append(neighbours[nI]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (debug > 1)
+        {
+            if (sum(visited) != allCells)
+            {
+                FatalErrorIn("dynamicTopoFvMesh::reOrderCells()") << nl
+                    << " Algorithm did not visit every cell in the mesh."
+                    << " Something's messed up." << nl
+                    << abort(FatalError);
+            }
+        }
+    }
+    else
+    {
+        // No bandwidth reduction. Fill-in sequentially.
+        for (label cellI = 0; cellI < nOldCells_; cellI++)
+        {
+            // Check if this is a deleted cell
+            if (reverseCellMap_[cellI] == -1)
+            {
+                continue;
+            }
+
+            // Update the cell info
+            cells_[cellInOrder].transfer(oldCells[cellI]);
+
+            // Update maps
+            cellMap_[cellInOrder] = cellI;
+            reverseCellMap_[cellI] = cellInOrder;
+
+            // Update the counter
+            cellInOrder++;
+        }
+
+        for (label cellI = nOldCells_; cellI < allCells; cellI++)
+        {
+            // Was this cell removed after addition?
+            if (deletedCells_.found(cellI))
+            {
+                continue;
+            }
+
+            // Update the cell info
+            cells_[cellInOrder].transfer(oldCells[cellI]);
+
+            // Put inserted cells in a seperate hashSet
+            addedCellRenumbering_.insert(cellI, cellInOrder);
+
+            // Update the counter
+            cellInOrder++;
+        }
+
+        // Final check to ensure everything went okay
+        if (cellInOrder != nCells_)
+        {
+            FatalErrorIn("dynamicTopoFvMesh::reOrderCells()") << nl
+                << " Algorithm did not visit every cell in the mesh."
+                << " Something's messed up." << nl
+                << abort(FatalError);
+        }
+    }
+
+    // Now that we're done preparing the cell maps, unlock the cell mutex
+    if (threaded)
+    {
+        entityMutex_[3].unlock();
+    }
+
+    // Renumber all maps.
+    forAll(cellsFromPoints_, cellI)
+    {
+        objectMap& thisMap = cellsFromPoints_[cellI];
+
+        if (thisMap.index() < nOldCells_)
+        {
+            thisMap.index() = reverseCellMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedCellRenumbering_[thisMap.index()];
+        }
+    }
+
+    forAll(cellsFromEdges_, cellI)
+    {
+        objectMap& thisMap = cellsFromEdges_[cellI];
+
+        if (thisMap.index() < nOldCells_)
+        {
+            thisMap.index() = reverseCellMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedCellRenumbering_[thisMap.index()];
+        }
+    }
+
+    forAll(cellsFromFaces_, cellI)
+    {
+        objectMap& thisMap = cellsFromFaces_[cellI];
+
+        if (thisMap.index() < nOldCells_)
+        {
+            thisMap.index() = reverseCellMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedCellRenumbering_[thisMap.index()];
+        }
+    }
+
+    forAll(cellsFromCells_, cellI)
+    {
+        objectMap& thisMap = cellsFromCells_[cellI];
+
+        if (thisMap.index() < nOldCells_)
+        {
+            thisMap.index() = reverseCellMap_[thisMap.index()];
+        }
+        else
+        {
+            thisMap.index() = addedCellRenumbering_[thisMap.index()];
+        }
+    }
+
+    // Prepare the cellZoneMap
+    cellZoneMesh& cellZones = polyMesh::cellZones();
+
+    labelListList newCellZoneAddr(cellZones.size());
+    labelList nCellsInZone(cellZones.size(), 0);
+
+    // Prepare zone maps.
+    forAll(cellZones, czI)
+    {
+        // Get the list of old cells
+        const labelList& oldAddr = cellZones[czI];
+
+        label& curNCells = nCellsInZone[czI];
+
+        // First count the actual number of cells in each zone.
+        forAll(oldAddr, cellI)
+        {
+            // Was this zone cell deleted? Don't count it.
+            if (reverseCellMap_[oldAddr[cellI]] != -1)
+            {
+                curNCells++;
+            }
+        }
+
+        // Check for added cells as well
+        forAllIter(Map<label>, addedCellZones_, cIter)
+        {
+            if (cIter() == czI)
+            {
+                curNCells++;
+            }
+        }
+
+        label cIndex = 0;
+        labelList& newAddr = newCellZoneAddr[czI];
+
+        // Set the sizes first
+        newAddr.setSize(curNCells);
+        cellZoneMap[czI].setSize(curNCells, -1);
+
+        // Add existing zone cells which have been renumbered.
+        forAll(oldAddr, cellI)
+        {
+            if (reverseCellMap_[oldAddr[cellI]] != -1)
+            {
+                cellZoneMap[czI][cIndex] = oldAddr[cellI];
+                newAddr[cIndex] = reverseCellMap_[oldAddr[cellI]];
+                cIndex++;
+            }
+        }
+
+        // Next, add the newly added zone cells.
+        forAllIter(Map<label>, addedCellZones_, cIter)
+        {
+            if (cIter() == czI)
+            {
+                newAddr[cIndex++] = addedCellRenumbering_[cIter.key()];
+            }
+        }
+
+        // Finally, assign addressing to this zone.
+        cellZones[czI] = newCellZoneAddr[czI];
+    }
+
+    // Reset all zones
+    cellZones.updateMesh();
+
+    if (debug)
+    {
+        Info << "Done." << endl;
+    }
+}
+
+
+// Static equivalent for multi-threading
+void dynamicTopoFvMesh::reOrderCellsThread
+(
+    void *argument
+)
+{
+    // Recast the argument
+    meshHandler *thread = static_cast<meshHandler*>(argument);
+
+    dynamicTopoFvMesh& mesh = thread->reference();
+
+    // Lock the cell mutex first
+    mesh.entityMutex(3).lock();
+
+    // Signal the calling thread
+    thread->sendSignal(meshHandler::START);
+
+    // Recast the pointers for the argument
+    labelListList& cellZoneMap =
+    (
+        *(static_cast<labelListList*>(thread->operator()(0)))
+    );
+
+    // Reorder the cells
+    mesh.reOrderCells(cellZoneMap, true);
+}
+
+
+// Reorder the faces in upper-triangular order, and generate mapping information
+void dynamicTopoFvMesh::reOrderMesh
+(
+    pointField& points,
+    pointField& preMotionPoints,
+    edgeList& edges,
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour,
+    labelListList& faceEdges,
+    labelListList& edgeFaces,
+    labelListList& pointZoneMap,
+    labelListList& faceZoneFaceMap,
+    labelListList& cellZoneMap
+)
+{
+    if (debug)
+    {
+        Info << endl;
+        Info << "=================" << endl;
+        Info << " Mesh reOrdering " << endl;
+        Info << "=================" << endl;
+        Info << "Mesh Info [n]:" << endl;
+        Info << "Points: " << nOldPoints_ << endl;
+        Info << "Edges: " << nOldEdges_ << endl;
+        Info << "Faces: " << nOldFaces_ << endl;
+        Info << "Cells: " << nOldCells_ << endl;
+        Info << "Internal Edges: " << nOldInternalEdges_ << endl;
+        Info << "Internal Faces: " << nOldInternalFaces_ << endl;
+        if (debug > 1)
+        {
+            Info << "Patch Starts [Face]: " << oldPatchStarts_ << endl;
+            Info << "Patch Sizes  [Face]: " << oldPatchSizes_ << endl;
+            Info << "Patch Starts [Edge]: " << oldEdgePatchStarts_ << endl;
+            Info << "Patch Sizes  [Edge]: " << oldEdgePatchSizes_ << endl;
+        }
+        Info << "=================" << endl;
+        Info << "Mesh Info [n+1]:" << endl;
+        Info << "Points: " << nPoints_ << endl;
+        Info << "Edges: " << nEdges_ << endl;
+        Info << "Faces: " << nFaces_ << endl;
+        Info << "Cells: " << nCells_ << endl;
+        Info << "Internal Edges: " << nInternalEdges_ << endl;
+        Info << "Internal Faces: " << nInternalFaces_ << endl;
+        if (debug > 1)
+        {
+            Info << "Patch Starts [Face]: " << patchStarts_ << endl;
+            Info << "Patch Sizes: [Face]: " << patchSizes_ << endl;
+            Info << "Patch Starts [Edge]: " << edgePatchStarts_ << endl;
+            Info << "Patch Sizes: [Edge]: " << edgePatchSizes_ << endl;
+        }
+        Info << "=================" << endl;
+
+        // Check connectivity structures for consistency
+        // before entering the reOrdering phase.
+        checkConnectivity();
+    }
+
+    if (threader_->multiThreaded())
+    {
+        // Initialize multi-threaded reOrdering
+        threadedMeshReOrdering
+        (
+            points,
+            preMotionPoints,
+            edges,
+            faces,
+            owner,
+            neighbour,
+            faceEdges,
+            edgeFaces,
+            pointZoneMap,
+            faceZoneFaceMap,
+            cellZoneMap
+        );
+    }
+    else
+    {
+        // Reorder the points
+        reOrderPoints(points, preMotionPoints, pointZoneMap);
+
+        // Reorder the cells
+        reOrderCells(cellZoneMap);
+
+        // Reorder the faces
+        reOrderFaces(faces, owner, neighbour, faceEdges, faceZoneFaceMap);
+
+        // Reorder the edges
+        reOrderEdges(edges, edgeFaces, faceEdges);
+    }
+}
+
+
+// Invoke reOrdering with multiple threads
+void dynamicTopoFvMesh::threadedMeshReOrdering
+(
+    pointField& points,
+    pointField& preMotionPoints,
+    edgeList& edges,
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour,
+    labelListList& faceEdges,
+    labelListList& edgeFaces,
+    labelListList& pointZoneMap,
+    labelListList& faceZoneFaceMap,
+    labelListList& cellZoneMap
+)
+{
+    // For reOrdering, one handler for each reOrdering method
+    PtrList<meshHandler> reOrderPtr(4);
+
+    // Initialize reOrdering handlers
+    forAll(reOrderPtr, memberI)
+    {
+        reOrderPtr.set
+        (
+            memberI,
+            new meshHandler(*this, threader())
+        );
+    }
+
+    // Set argument sizes for individual members
+
+    // Points take three arguments
+    // (Two pointFields and one labelListList)
+    reOrderPtr[0].setSize(3);
+
+    // Prepare pointers for point reOrdering
+    reOrderPtr[0].set(0, &points);
+    reOrderPtr[0].set(1, &preMotionPoints);
+    reOrderPtr[0].set(2, &pointZoneMap);
+
+    // Edges take three arguments
+    // (One edgeList and two labelListLists)
+    reOrderPtr[1].setSize(3);
+
+    // Prepare pointers for edge reOrdering
+    reOrderPtr[1].set(0, &edges);
+    reOrderPtr[1].set(1, &edgeFaces);
+    reOrderPtr[1].set(2, &faceEdges);
+
+    // Faces take five arguments
+    // (One faceList, two labelLists, and two labelListLists)
+    reOrderPtr[2].setSize(5);
+
+    // Prepare pointers for face reOrdering
+    reOrderPtr[2].set(0, &faces);
+    reOrderPtr[2].set(1, &owner);
+    reOrderPtr[2].set(2, &neighbour);
+    reOrderPtr[2].set(3, &faceEdges);
+    reOrderPtr[2].set(4, &faceZoneFaceMap);
+
+    // Cells take one argument
+    // (One labelListList)
+    reOrderPtr[3].setSize(1);
+
+    // Prepare pointers for cell reOrdering
+    reOrderPtr[3].set(0, &cellZoneMap);
+
+    // Set the thread scheduling sequence
+    labelList reOrderSeq(4, -1);
+
+    // Points, cells, faces and edges (in that order)
+    reOrderSeq[0] = 0;
+    reOrderSeq[1] = 3;
+    reOrderSeq[2] = 2;
+    reOrderSeq[3] = 1;
+
+    // Lock all slave threads first
+    forAll(reOrderSeq, i)
+    {
+        reOrderPtr[reOrderSeq[i]].lock(meshHandler::START);
+        reOrderPtr[reOrderSeq[i]].unsetPredicate(meshHandler::START);
+    }
+
+    // Submit points to the work queue
+    threader_->addToWorkQueue
+    (
+        &reOrderPointsThread,
+        &(reOrderPtr[0])
+    );
+
+    // Wait for a signal from this thread before moving on.
+    reOrderPtr[0].waitForSignal(meshHandler::START);
+
+    // Submit cells to the work queue
+    threader_->addToWorkQueue
+    (
+        &reOrderCellsThread,
+        &(reOrderPtr[3])
+    );
+
+    // Wait for a signal from this thread before moving on.
+    reOrderPtr[3].waitForSignal(meshHandler::START);
+
+    // Submit faces to the work queue
+    threader_->addToWorkQueue
+    (
+        &reOrderFacesThread,
+        &(reOrderPtr[2])
+    );
+
+    // Wait for a signal from this thread before moving on.
+    reOrderPtr[2].waitForSignal(meshHandler::START);
+
+    // Lock the edge stop-mutex
+    reOrderPtr[1].lock(meshHandler::STOP);
+    reOrderPtr[1].unsetPredicate(meshHandler::STOP);
+
+    // Submit edges to the work queue
+    threader_->addToWorkQueue
+    (
+        &reOrderEdgesThread,
+        &(reOrderPtr[1])
+    );
+
+    // Wait for a signal from this thread before moving on.
+    reOrderPtr[1].waitForSignal(meshHandler::START);
+
+    // Wait for edges to be reOrdered before moving on.
+    reOrderPtr[1].waitForSignal(meshHandler::STOP);
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.C
new file mode 100644
index 000000000..0531176e7
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.C
@@ -0,0 +1,295 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "eBoundaryMesh.H"
+#include "eMesh.H"
+#include "primitiveMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(eBoundaryMesh, 0);
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from dictionary
+eBoundaryMesh::eBoundaryMesh
+(
+    const IOobject& io,
+    const eMesh& mesh
+)
+:
+    ePatchList(),
+    regIOobject(io),
+    mesh_(mesh)
+{
+    if
+    (
+        (readOpt() == IOobject::MUST_READ) ||
+        (readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readFromInputStream();
+    }
+}
+
+
+// Construct given size. Patches will be set later
+eBoundaryMesh::eBoundaryMesh
+(
+    const IOobject& io,
+    const eMesh& em,
+    const label size
+)
+:
+    ePatchList(size),
+    regIOobject(io),
+    mesh_(em)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Read from input stream
+void eBoundaryMesh::readFromInputStream()
+{
+    ePatchList& patches = *this;
+
+    // Read polyPatchList
+    Istream& is = readStream(typeName);
+
+    PtrList<entry> patchEntries(is);
+    patches.setSize(patchEntries.size());
+
+    forAll(patches, patchI)
+    {
+        patches.set
+        (
+            patchI,
+            ePatch::New
+            (
+                patchEntries[patchI].keyword(),
+                patchEntries[patchI].dict(),
+                patchI,
+                *this
+            )
+        );
+    }
+
+    // Check state of IOstream
+    is.check
+    (
+        "eBoundaryMesh::eBoundaryMesh"
+        "(const IOobject&, const faMesh&)"
+    );
+
+    close();
+}
+
+// Return the mesh reference
+const eMesh& eBoundaryMesh::mesh() const
+{
+    return mesh_;
+}
+
+
+// Return a list of patch types
+wordList eBoundaryMesh::types() const
+{
+    const ePatchList& patches = *this;
+
+    wordList t(patches.size());
+
+    forAll (patches, patchI)
+    {
+        t[patchI] = patches[patchI].type();
+    }
+
+    return t;
+}
+
+
+// Return a list of patch names
+wordList eBoundaryMesh::names() const
+{
+    const ePatchList& patches = *this;
+
+    wordList t(patches.size());
+
+    forAll (patches, patchI)
+    {
+        t[patchI] = patches[patchI].name();
+    }
+
+    return t;
+}
+
+
+// Return a list of patch sizes
+labelList eBoundaryMesh::patchSizes() const
+{
+    const ePatchList& patches = *this;
+
+    labelList t(patches.size());
+
+    forAll (patches, patchI)
+    {
+        t[patchI] = patches[patchI].size();
+    }
+
+    return t;
+}
+
+
+// Return a list of patch starts
+labelList eBoundaryMesh::patchStarts() const
+{
+    const ePatchList& patches = *this;
+
+    labelList t(patches.size());
+
+    forAll (patches, patchI)
+    {
+        t[patchI] = patches[patchI].start();
+    }
+
+    return t;
+}
+
+
+//- Return patch index for a given edge label
+label eBoundaryMesh::whichPatch(const label edgeIndex) const
+{
+    // Find out which patch the current edge belongs to by comparing label
+    // with patch start labels.
+    // If the face is internal, return -1;
+    // if it is off the end of the list, abort
+    if (edgeIndex >= mesh().nEdges())
+    {
+        FatalErrorIn
+        (
+            "eBoundaryMesh::whichPatch(const label edgeIndex) const"
+        )   << "given label greater than the number of geometric edges"
+            << abort(FatalError);
+    }
+
+    if (edgeIndex < mesh().nInternalEdges())
+    {
+        return -1;
+    }
+
+    forAll (*this, patchI)
+    {
+        const ePatch& bp = operator[](patchI);
+
+        if
+        (
+            edgeIndex >= bp.start()
+         && edgeIndex < bp.start() + bp.size()
+        )
+        {
+            return patchI;
+        }
+    }
+
+    // If not in any of above, it is trouble!
+    FatalErrorIn
+    (
+        "label eBoundaryMesh::whichPatch(const label edgeIndex) const"
+    )   << "Cannot find edge " << edgeIndex << " in any of the patches "
+        << names() << nl
+        << "It seems your patches are not consistent with the mesh :"
+        << " internalEdges:" << mesh().nInternalEdges()
+        << "  total number of edges:" << mesh().nEdges()
+        << abort(FatalError);
+
+    return -1;
+}
+
+
+label eBoundaryMesh::findPatchID(const word& patchName) const
+{
+    const ePatchList& patches = *this;
+
+    forAll (patches, patchI)
+    {
+        if (patches[patchI].name() == patchName)
+        {
+            return patchI;
+        }
+    }
+
+    // Patch not found
+    return -1;
+}
+
+
+// writeData member function required by regIOobject
+bool eBoundaryMesh::writeData(Ostream& os) const
+{
+    const ePatchList& patches = *this;
+
+    os  << patches.size() << nl << token::BEGIN_LIST << incrIndent << nl;
+
+    forAll(patches, patchi)
+    {
+        os  << indent << patches[patchi].name() << nl
+            << indent << token::BEGIN_BLOCK << nl
+            << incrIndent << patches[patchi] << decrIndent
+            << indent << token::END_BLOCK << endl;
+    }
+
+    os  << decrIndent << token::END_LIST;
+
+    // Check state of IOstream
+    os.check("eBoundaryMesh::writeData(Ostream& os) const");
+
+    return os.good();
+}
+
+
+Ostream& operator<<(Ostream& os, const eBoundaryMesh& bm)
+{
+    bm.writeData(os);
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.H
new file mode 100644
index 000000000..c141ac62f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eBoundaryMesh/eBoundaryMesh.H
@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    eBoundaryMesh
+
+SourceFiles
+    eBoundaryMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef eBoundaryMesh_H
+#define eBoundaryMesh_H
+
+#include "ePatchList.H"
+#include "wordList.H"
+#include "pointField.H"
+#include "regIOobject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+class eMesh;
+
+/*---------------------------------------------------------------------------*\
+                      Class eBoundaryMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class eBoundaryMesh
+:
+    public ePatchList,
+    public regIOobject
+{
+    // private data
+
+        //- Reference to mesh
+        const eMesh& mesh_;
+
+        //- Disallow construct as copy
+        eBoundaryMesh(const eBoundaryMesh&);
+
+        //- Disallow assignment
+        void operator=(const eBoundaryMesh&);
+
+public:
+
+    //- Runtime type information
+    TypeName("eBoundaryMesh");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        eBoundaryMesh
+        (
+            const IOobject& io,
+            const eMesh& mesh
+        );
+
+        //- Construct given size
+        eBoundaryMesh
+        (
+            const IOobject& io,
+            const eMesh& mesh,
+            const label size
+        );
+
+
+    // Destructor - default
+
+
+    // Member functions
+
+        // Access
+
+            //- Return the mesh reference
+            const eMesh& mesh() const;
+
+            //- Return a list of patch types
+            wordList types() const;
+
+            //- Return a list of patch names
+            wordList names() const;
+
+            //- Return a list of patch sizes
+            labelList patchSizes() const;
+
+            //- Return a list of patch starts
+            labelList patchStarts() const;
+
+            //- Return patch index for a given edge label
+            label whichPatch(const label edgeIndex) const;
+
+            //- Find patch index given a name
+            label findPatchID(const word& patchName) const;
+
+            //- writeData member function required by regIOobject
+            bool writeData(Ostream&) const;
+
+        // Input / Output
+
+            //- Read from input stream
+            void readFromInputStream();
+
+    // Ostream operator
+
+        friend Ostream& operator<<(Ostream&, const eBoundaryMesh&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
new file mode 100644
index 000000000..167c5977f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.C
@@ -0,0 +1,482 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+    Mesh needed to do edge-based addressing.
+
+\*---------------------------------------------------------------------------*/
+
+#include "eMesh.H"
+#include "demandDrivenData.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(eMesh, 0);
+
+word eMesh::meshSubDir = "eMesh";
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void eMesh::clearGeom() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::clearGeom() const : "
+            << "Clearing geometry" << endl;
+    }
+}
+
+
+void eMesh::clearAddressing() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::clearAddressing() const : "
+            << "Clearing addressing" << endl;
+    }
+
+    edges_.clear();
+
+    deleteDemandDrivenData(pePtr_);
+    deleteDemandDrivenData(epPtr_);
+    deleteDemandDrivenData(fePtr_);
+    deleteDemandDrivenData(efPtr_);
+}
+
+
+// Helper function to isolate points on triangular faces
+label eMesh::findIsolatedPoint(const face& f, const edge& e) const
+{
+    // Check the first point
+    if ( f[0] != e.start() && f[0] != e.end() )
+    {
+        return f[0];
+    }
+
+    // Check the second point
+    if ( f[1] != e.start() && f[1] != e.end() )
+    {
+        return f[1];
+    }
+
+    // Check the third point
+    if ( f[2] != e.start() && f[2] != e.end() )
+    {
+        return f[2];
+    }
+
+    return -1;
+}
+
+
+//- Helper function to determine the orientation of a triangular face
+label eMesh::edgeDirection(const face& f, const edge& e) const
+{
+    if
+    (
+        (f[0] == e.start() && f[1] == e.end())
+     || (f[1] == e.start() && f[2] == e.end())
+     || (f[2] == e.start() && f[0] == e.end())
+    )
+    {
+        // Return counter-clockwise
+        return 1;
+    }
+    else
+    {
+        // Return clockwise
+        return -1;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+eMesh::eMesh(const polyMesh& pMesh, const word& subDir)
+:
+    objectRegistry(pMesh.time()),
+    mesh_(pMesh),
+    edges_
+    (
+        IOobject
+        (
+            "edges",
+            mesh_.facesInstance(),
+            subDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        )
+    ),
+    boundary_
+    (
+        IOobject
+        (
+            "edgeBoundary",
+            mesh_.facesInstance(),
+            subDir,
+            mesh_,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        ),
+        *this
+    ),
+    pePtr_(NULL),
+    epPtr_(NULL),
+    fePtr_(NULL),
+    efPtr_(NULL)
+{
+    if (debug)
+    {
+        Info << "eMesh::eMesh(const polyMesh&, const word&) : "
+             << "Creating eMesh from polyMesh"
+             << endl;
+    }
+
+    // Re-initialize / override meshSubDir
+    meshSubDir = subDir;
+
+    // Try to read from disk.
+    if (edges_.headerOk() && boundary_.headerOk())
+    {
+        // Set sizes
+        nEdges_ = edges_.size();
+        nInternalEdges_ = boundary_[0].start();
+    }
+    else
+    {
+        // Could not read ordered edges, so calculate it instead.
+        calcOrderedEdgeList();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+eMesh::~eMesh()
+{
+    clearOut();
+}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+fileName eMesh::meshDir() const
+{
+    return mesh_.dbDir();
+}
+
+
+fileName eMesh::meshSubDirectory() const
+{
+    return mesh_.dbDir()/meshSubDir;
+}
+
+
+const Time& eMesh::time() const
+{
+    return mesh_.time();
+}
+
+
+label eMesh::nEdges() const
+{
+    return nEdges_;
+}
+
+
+label eMesh::nInternalEdges() const
+{
+    return nInternalEdges_;
+}
+
+
+const edgeList& eMesh::edges() const
+{
+    return edges_;
+}
+
+
+void eMesh::addEdgePatches(const List<ePatch*>& p)
+{
+    if (debug)
+    {
+        Info << "void eMesh::addEdgePatches(const List<ePatch*>& p) : "
+             << "Adding patches to eMesh" << endl;
+    }
+
+    if (boundary().size() > 0)
+    {
+        FatalErrorIn
+        (
+            "void eMesh::addEdgePatches(const List<ePatch*>& p)"
+        )
+            << "Boundary already exists"
+            << abort(FatalError);
+    }
+
+    boundary_.setSize(p.size());
+
+    forAll(p, patchI)
+    {
+        boundary_.set(patchI, p[patchI]);
+    }
+}
+
+
+const objectRegistry& eMesh::db() const
+{
+    return mesh_.db();
+}
+
+
+const eBoundaryMesh& eMesh::boundary() const
+{
+    return boundary_;
+}
+
+
+void eMesh::resetPrimitives
+(
+    edgeList& edges,
+    labelListList& faceEdges,
+    labelListList& edgeFaces,
+    const labelList& patchSizes,
+    const labelList& patchStarts,
+    const bool reUse,
+    const bool storePrimitives
+)
+{
+    // Clear out geometry and addressing
+    clearOut();
+
+    // Initialize pointers for storage
+    if (storePrimitives)
+    {
+        fePtr_ =
+        (
+            new labelListIOList
+            (
+                IOobject
+                (
+                    "faceEdges",
+                    mesh_.facesInstance(),
+                    meshSubDir,
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                )
+            )
+        );
+
+        efPtr_ =
+        (
+            new labelListIOList
+            (
+                IOobject
+                (
+                    "edgeFaces",
+                    mesh_.facesInstance(),
+                    meshSubDir,
+                    mesh_,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                )
+            )
+        );
+
+        if (reUse)
+        {
+            edges_.transfer(edges);
+            fePtr_->transfer(faceEdges);
+            efPtr_->transfer(edgeFaces);
+        }
+        else
+        {
+            edges_ = edges;
+            fePtr_->operator=(faceEdges);
+            efPtr_->operator=(edgeFaces);
+        }
+    }
+
+    // Reset patch sizes and starts
+    forAll(boundary_, patchI)
+    {
+        boundary_[patchI] = ePatch
+        (
+            boundary_[patchI].name(),
+            patchSizes[patchI],
+            patchStarts[patchI],
+            patchI,
+            boundary_
+        );
+    }
+
+    // Reset size information
+    nEdges_ = edges.size();
+    nInternalEdges_ = boundary_[0].start();
+
+    // Set mesh files as changed
+    setInstance(time().timeName());
+}
+
+
+//- Clear demand-driven data
+void eMesh::clearOut() const
+{
+    clearGeom();
+    clearAddressing();
+}
+
+
+//- Set the instance for mesh files
+void eMesh::setInstance(const fileName& inst)
+{
+    if (debug)
+    {
+        Info<< "void eMesh::setInstance(const fileName& inst) : "
+            << "Resetting file instance to " << inst << endl;
+    }
+
+    if (edges_.size())
+    {
+        edges_.writeOpt() = IOobject::AUTO_WRITE;
+        edges_.instance() = inst;
+    }
+
+    if (efPtr_)
+    {
+        efPtr_->writeOpt() = IOobject::AUTO_WRITE;
+        efPtr_->instance() = inst;
+    }
+
+    if (fePtr_)
+    {
+        fePtr_->writeOpt() = IOobject::AUTO_WRITE;
+        fePtr_->instance() = inst;
+    }
+
+    // Write out boundary information only
+    // if all others are being written out
+    if (edges_.size() && efPtr_ && fePtr_)
+    {
+        boundary_.writeOpt() = IOobject::AUTO_WRITE;
+        boundary_.instance() = 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_)
+    {
+        calcFaceEdges();
+    }
+
+    return *fePtr_;
+}
+
+
+const labelListList& eMesh::edgeFaces() const
+{
+    if (!efPtr_)
+    {
+        calcEdgeFaces();
+    }
+
+    return *efPtr_;
+}
+
+
+bool eMesh::write() const
+{
+    if (edges_.size())
+    {
+        edges_.write();
+    }
+
+    if (efPtr_)
+    {
+        efPtr_->write();
+    }
+
+    if (fePtr_)
+    {
+        fePtr_->write();
+    }
+
+    if (edges_.size() && efPtr_ && fePtr_)
+    {
+        boundary_.write();
+    }
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+bool eMesh::operator!=(const eMesh& m) const
+{
+    return &m != this;
+}
+
+bool eMesh::operator==(const eMesh& m) const
+{
+    return &m == this;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
new file mode 100644
index 000000000..576207678
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMesh.H
@@ -0,0 +1,251 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    eMesh
+
+Description
+    Mesh class to store edge-based connectivity structures.
+
+SourceFiles
+    eMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef eMesh_H
+#define eMesh_H
+
+#include "Time.H"
+#include "polyMesh.H"
+#include "edgeIOList.H"
+#include "labelIOList.H"
+#include "eBoundaryMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+
+/*---------------------------------------------------------------------------*\
+                           Class eMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class eMesh
+:
+    public objectRegistry
+{
+    // Private data
+
+        const polyMesh& mesh_;
+
+        //- Ordered edge-list
+        mutable edgeIOList edges_;
+
+        //- Boundary mesh
+        mutable eBoundaryMesh boundary_;
+
+        // Primitive size data
+
+            //- Number of edges
+            mutable label nEdges_;
+
+            //- Number of internal edges
+            mutable label nInternalEdges_;
+
+    // Demand-driven data
+
+            //- 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_;
+
+            //- Edge-faces
+            mutable labelListIOList* efPtr_;
+
+    // Private Member Functions
+
+        //- Helper function to isolate points on triangular faces
+        label findIsolatedPoint(const face& f, const edge& e) const;
+
+        //- Helper function to determine the orientation of a triangular face
+        label edgeDirection(const face& f, const edge& e) const;
+
+        //- Disallow default bitwise copy construct
+        eMesh(const eMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const eMesh&);
+
+        // Private member functions to calculate demand driven data
+
+            //- 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;
+
+            //- Calculate edge-faces
+            void calcEdgeFaces() const;
+
+            //- Clear geometry
+            void clearGeom() const;
+
+            //- Clear addressing
+            void clearAddressing() const;
+
+public:
+
+    // Public typedefs
+
+        typedef eMesh Mesh;
+        typedef eBoundaryMesh BoundaryMesh;
+
+
+    //- Runtime type information
+    TypeName("eMesh");
+
+    //- Return the mesh sub-directory name (usually "eMesh")
+    static word meshSubDir;
+
+
+    // Constructors
+
+        //- Construct from IOobject and polyMesh reference
+        eMesh(const polyMesh& m, const word& subDir = eMesh::meshSubDir);
+
+
+    // Destructor
+
+        virtual ~eMesh();
+
+
+    // Member Functions
+
+        // Helpers
+
+            //- Add boundary patches. Constructor helper
+            void addEdgePatches(const List<ePatch*> &);
+
+
+        // Database
+
+            //- Return reference to the mesh database
+            virtual const objectRegistry& db() const;
+
+            //- Return the base mesh directory (dbDir())
+            fileName meshDir() const;
+
+            //- Return the local mesh directory (dbDir()/meshSubDir)
+            fileName meshSubDirectory() const;
+
+            //- Return reference to time
+            const Time& time() const;
+
+
+            //- Mesh size parameters
+
+                label nEdges() const;
+
+                label nInternalEdges() const;
+
+            // Primitive mesh data
+
+                //- Return constant reference to the ordered edge-list
+                const edgeList& edges() const;
+
+        // Access
+
+            //- Return constant reference to boundary mesh
+            const eBoundaryMesh& boundary() const;
+
+
+        // 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;
+
+            //- Return constant reference to the edgeFaces list
+            const labelListList& edgeFaces() const;
+
+        // Reset primitive data
+        void resetPrimitives
+        (
+            edgeList& edges,
+            labelListList& faceEdges,
+            labelListList& edgeFaces,
+            const labelList& patchSizes,
+            const labelList& patchStarts,
+            const bool reUse,
+            const bool storePrimitives
+        );
+
+        //- Clear demand-driven data
+        void clearOut() const;
+
+        //- Set the instance for mesh files
+        void setInstance(const fileName& inst);
+
+        //- Write mesh
+        virtual bool write() const;
+
+
+    // Member Operators
+
+        bool operator!=(const eMesh& m) const;
+
+        bool operator==(const eMesh& m) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
new file mode 100644
index 000000000..3bc135bc2
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/eMeshDemandDrivenData.C
@@ -0,0 +1,467 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "eMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Calculate ordered edges
+void eMesh::calcOrderedEdgeList()
+{
+    if (debug)
+    {
+        Info<< "void eMesh::calcOrderedEdges() const : "
+            << "Calculating ordered edges" << endl;
+    }
+
+    if (edges_.size() || boundary_.size())
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcOrderedEdges() const"
+        )   << "Ordered edges already allocated."
+            << abort(FatalError);
+    }
+
+    // Set size first.
+    nEdges_ = mesh_.nEdges();
+    nInternalEdges_ = 0;
+    boundary_.setSize(mesh_.boundaryMesh().size());
+
+    // Allocate lists for re-ordering
+    labelList edgePatch(nEdges_, -1);
+    labelList edgePatchStarts(mesh_.boundaryMesh().size(), -1);
+    labelList edgePatchSizes(mesh_.boundaryMesh().size(), 0);
+
+    reverseEdgeMap_.setSize(nEdges_);
+
+    // Obtain connectivity from primitive mesh
+    const edgeList& edges = mesh_.edges();
+    const labelListList& fEdges = mesh_.faceEdges();
+
+    // Edge-patches are the same as faces
+    for (label i = mesh_.nInternalFaces(); i < mesh_.nFaces(); i++)
+    {
+        const labelList& fEdge = fEdges[i];
+
+        forAll(fEdge, edgeI)
+        {
+            edgePatch[fEdge[edgeI]] = mesh_.boundaryMesh().whichPatch(i);
+        }
+    }
+
+    // Loop through edgePatch and renumber internal edges
+    forAll(edgePatch, edgeI)
+    {
+        if (edgePatch[edgeI] == -1)
+        {
+            reverseEdgeMap_[edgeI] = nInternalEdges_++;
+        }
+        else
+        {
+            edgePatchSizes[edgePatch[edgeI]]++;
+        }
+    }
+
+    // Calculate patch-starts
+    label startCount = nInternalEdges_;
+
+    forAll(edgePatchStarts, patchI)
+    {
+        edgePatchStarts[patchI] = startCount;
+        startCount += edgePatchSizes[patchI];
+    }
+
+    // Now renumber boundary edges
+    labelList patchCount(edgePatchStarts);
+
+    forAll(edgePatch, edgeI)
+    {
+        if (edgePatch[edgeI] > -1)
+        {
+            reverseEdgeMap_[edgeI] = patchCount[edgePatch[edgeI]]++;
+        }
+    }
+
+    // Renumber and fill in edges
+    edges_.setSize(nEdges_, edge(-1,-1));
+
+    forAll(edges, edgeI)
+    {
+        edges_[reverseEdgeMap_[edgeI]] = edges[edgeI];
+    }
+
+    // Now set the boundary, copy name. (type is default)
+    forAll(boundary_, patchI)
+    {
+        boundary_.set
+        (
+            patchI,
+            ePatch::New
+            (
+                ePatch::typeName_(),
+                mesh_.boundaryMesh()[patchI].name(),
+                edgePatchSizes[patchI],
+                edgePatchStarts[patchI],
+                patchI,
+                boundary_
+            )
+        );
+    }
+
+    // Force calculation of other data...
+    calcEdgeFaces();
+    calcFaceEdges();
+}
+
+void eMesh::calcEdgePoints() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::calcEdgePoints() const : "
+            << "Calculating ordered edgePoints" << endl;
+    }
+
+    if (epPtr_)
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcEdgePoints() const"
+        )   << "edgePoints already allocated."
+            << abort(FatalError);
+    }
+
+    if (!efPtr_->size())
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcEdgePoints() const"
+        )   << "edgeFaces doesn't exist."
+            << abort(FatalError);
+    }
+
+    // Size the list
+    epPtr_ = new labelListList(nEdges_);
+    labelListList& edgePoints = *epPtr_;
+
+    // EdgePoints are ordered such that points appear in
+    // counter-clockwise direction around point[0] of the edge.
+    // If a boundary point is present, that must begin the list.
+    // NOTE: Will work only on tetrahedral meshes!
+
+    bool found;
+    label faceIndex = -1, cellIndex = -1;
+    const labelList& owner = mesh_.faceOwner();
+    const labelList& neighbour = mesh_.faceNeighbour();
+    const cellList& cells = mesh_.cells();
+    const faceList& faces = mesh_.faces();
+    const labelListList& eFaces = this->edgeFaces();
+
+    for (label eIndex=0; eIndex < nEdges_; eIndex++)
+    {
+        const edge& e = edges_[eIndex];
+        const labelList& eFace = eFaces[eIndex];
+
+        // Size the list
+        edgePoints[eIndex].setSize(eFace.size(), -1);
+
+        if (eIndex < nInternalEdges_)
+        {
+            // Pick the first face and start with that
+            faceIndex = eFace[0];
+        }
+        else
+        {
+            // Need to find a properly oriented start-face
+            forAll(eFace, faceI)
+            {
+                if
+                (
+                    (!mesh_.isInternalFace(eFace[faceI]))
+                 && (edgeDirection(faces[eFace[faceI]], e) == 1)
+                )
+                {
+                    faceIndex = eFace[faceI];
+                    break;
+                }
+            }
+        }
+
+        // Shuffle vertices to appear in CCW order
+        for (label j=0; j < eFace.size(); j++)
+        {
+            const face& f = faces[faceIndex];
+
+            // Add the isolated point
+            edgePoints[eIndex][j] = findIsolatedPoint(f, e);
+
+            // Figure out how this edge is oriented.
+            if (edgeDirection(f, e) == 1)
+            {
+                // Counter-clockwise. Pick the owner.
+                cellIndex = owner[faceIndex];
+            }
+            else
+            if (mesh_.isInternalFace(faceIndex))
+            {
+                // Clockwise. Pick the neighbour.
+                cellIndex = neighbour[faceIndex];
+            }
+            else
+            {
+                // Looks like we've hit a boundary face. Break out.
+                break;
+            }
+
+            const cell& cellToCheck = cells[cellIndex];
+
+            found = false;
+
+            // Assuming tet-cells,
+            // Loop through edgeFaces and get the next face
+            forAll(eFace, faceI)
+            {
+                if
+                (
+                    eFace[faceI] != faceIndex
+                 && eFace[faceI] == cellToCheck[0]
+                )
+                {
+                    faceIndex = cellToCheck[0];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFace[faceI] != faceIndex
+                 && eFace[faceI] == cellToCheck[1]
+                )
+                {
+                    faceIndex = cellToCheck[1];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFace[faceI] != faceIndex
+                 && eFace[faceI] == cellToCheck[2]
+                )
+                {
+                    faceIndex = cellToCheck[2];
+                    found = true; break;
+                }
+
+                if
+                (
+                    eFace[faceI] != faceIndex
+                 && eFace[faceI] == cellToCheck[3]
+                )
+                {
+                    faceIndex = cellToCheck[3];
+                    found = true; break;
+                }
+            }
+
+#           ifdef FULLDEBUG
+            if (!found)
+            {
+                // Something's terribly wrong
+                FatalErrorIn
+                (
+                    "void eMesh::calcEdgePoints() const"
+                )
+                << " Failed to determine a vertex ring. " << nl
+                << " edgeFaces connectivity is inconsistent. " << nl
+                << "Edge: " << eIndex << ":: " << e << nl
+                << "edgeFaces: " << eFace
+                << abort(FatalError);
+            }
+#           endif
+        }
+    }
+}
+
+
+void eMesh::calcPointEdges() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::calcPointEdges() const : "
+            << "Calculating PointEdges" << endl;
+    }
+
+    if (pePtr_)
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcPointEdges() const"
+        )   << "pePtr_ already allocated"
+            << abort(FatalError);
+    }
+
+    pePtr_ = new labelListList(mesh_.nPoints());
+    invertManyToMany(mesh_.nPoints(), edges(), *pePtr_);
+}
+
+
+void eMesh::calcFaceEdges() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::calcFaceEdges() const : "
+            << "Calculating FaceEdges" << endl;
+    }
+
+    if (fePtr_)
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcFaceEdges() const"
+        )   << "fePtr_ already allocated"
+            << abort(FatalError);
+    }
+
+    fePtr_ =
+    (
+        new labelListIOList
+        (
+            IOobject
+            (
+                "faceEdges",
+                mesh_.facesInstance(),
+                meshSubDir,
+                mesh_,
+                IOobject::READ_IF_PRESENT,
+                IOobject::NO_WRITE
+            ),
+            mesh_.nFaces()
+        )
+    );
+
+    labelListIOList& faceEdges = *fePtr_;
+
+    // If the read was successful, return.
+    if (faceEdges.headerOk())
+    {
+        return;
+    }
+
+    // If edgeFaces exists, use that.
+    if (efPtr_)
+    {
+        invertManyToMany(mesh_.nFaces(), edgeFaces(), faceEdges);
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcFaceEdges() const"
+        )   << "Cannot calculate faceEdges."
+            << abort(FatalError);
+    }
+}
+
+void eMesh::calcEdgeFaces() const
+{
+    if (debug)
+    {
+        Info<< "void eMesh::calcEdgeFaces() const : "
+            << "Calculating EdgeFaces" << endl;
+    }
+
+    if (efPtr_)
+    {
+        FatalErrorIn
+        (
+            "void eMesh::calcEdgeFaces() const"
+        )   << "efPtr_ already allocated."
+            << abort(FatalError);
+    }
+
+    efPtr_ =
+    (
+        new labelListIOList
+        (
+            IOobject
+            (
+                "edgeFaces",
+                mesh_.facesInstance(),
+                meshSubDir,
+                mesh_,
+                IOobject::READ_IF_PRESENT,
+                IOobject::NO_WRITE
+            ),
+            nEdges_
+        )
+    );
+
+    labelListIOList& edgeFaces = *efPtr_;
+
+    // If the read was successful, return.
+    if (edgeFaces.headerOk())
+    {
+        return;
+    }
+
+    if (fePtr_)
+    {
+        // If faceEdges exists, use that.
+        invertManyToMany(nEdges_, faceEdges(), edgeFaces);
+    }
+    else
+    {
+        // Obtain connectivity from primitive mesh.
+        if (!reverseEdgeMap_.size())
+        {
+            FatalErrorIn
+            (
+                "void eMesh::calcEdgeFaces() const"
+            )   << "reverseEdgeMap has not been allocated."
+                << abort(FatalError);
+        }
+
+        const labelListList& eFaces = mesh_.edgeFaces();
+
+        forAll(eFaces, edgeI)
+        {
+            edgeFaces[reverseEdgeMap_[edgeI]] = eFaces[edgeI];
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
new file mode 100644
index 000000000..f5508c962
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.C
@@ -0,0 +1,138 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "ePatch.H"
+#include "addToRunTimeSelectionTable.H"
+#include "eBoundaryMesh.H"
+#include "eMesh.H"
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(ePatch, 0);
+
+defineRunTimeSelectionTable(ePatch, word);
+defineRunTimeSelectionTable(ePatch, dictionary);
+
+addToRunTimeSelectionTable(ePatch, ePatch, word);
+addToRunTimeSelectionTable(ePatch, ePatch, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::ePatch::ePatch
+(
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const eBoundaryMesh& bm
+)
+:
+    patchIdentifier(name, index),
+    boundaryMesh_(bm),
+    start_(start),
+    size_(size)
+{}
+
+
+// Construct from dictionary
+ePatch::ePatch
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const eBoundaryMesh& bm
+)
+:
+    patchIdentifier(name, dict, index),
+    boundaryMesh_(bm),
+    start_(readLabel(dict.lookup("start"))),
+    size_(readLabel(dict.lookup("size")))
+{}
+
+ePatch::ePatch(const ePatch& p, const eBoundaryMesh& bm)
+:
+    patchIdentifier(p, p.index()),
+    boundaryMesh_(bm),
+    start_(p.start()),
+    size_(p.size())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+ePatch::~ePatch()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const eBoundaryMesh& ePatch::boundaryMesh() const
+{
+    return boundaryMesh_;
+}
+
+
+void ePatch::write(Ostream& os) const
+{
+    os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
+    os.writeKeyword("start") << start() << token::END_STATEMENT << nl;
+    os.writeKeyword("size") << size() << token::END_STATEMENT << nl;
+    patchIdentifier::write(os);
+}
+
+
+//- Assignment operator
+void ePatch::operator=(const ePatch& p)
+{
+    patchIdentifier::operator=(p);
+    start_ = p.start_;
+    size_ = p.size_;
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Ostream& operator<<(Ostream& os, const ePatch& p)
+{
+    p.write(os);
+    os.check("Ostream& operator<<(Ostream& f, const faPatch& p)");
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
new file mode 100644
index 000000000..94813b5f0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatch.H
@@ -0,0 +1,265 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    ePatch
+
+SourceFiles
+    ePatch.C
+    newEPatch.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ePatch_H
+#define ePatch_H
+
+#include "patchIdentifier.H"
+#include "labelList.H"
+#include "pointField.H"
+#include "typeInfo.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class eBoundaryMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class ePatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class ePatch
+:
+    public patchIdentifier
+{
+private:
+
+    // Private data
+
+        //- Reference to boundary mesh
+        const eBoundaryMesh& boundaryMesh_;
+
+        //- Start index of the patch
+        label start_;
+
+        //- 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
+        friend class eBoundaryMesh;
+
+        //- Initialise the calculation of the patch geometry
+        virtual void initGeometry()
+        {}
+
+        //- Calculate the patch geometry
+        virtual void calcGeometry()
+        {}
+
+        //- Initialise the patches for moving points
+        virtual void initMovePoints(const pointField&)
+        {}
+
+        //- Correct patch after moving points
+        virtual void movePoints(const pointField&)
+        {}
+
+        //- Initialise the update of the patch topology
+        virtual void initUpdateMesh()
+        {}
+
+        //- Update of the patch topology
+        virtual void updateMesh()
+        {}
+
+
+public:
+
+    typedef eBoundaryMesh BoundaryMesh;
+
+
+    //- Runtime type information
+    TypeName("patch");
+
+    // Declare run-time constructor selection tables
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            ePatch,
+            word,
+            (
+                const word& name,
+                const label size,
+                const label start,
+                const label index,
+                const eBoundaryMesh& bm
+            ),
+            (name, size, start, index, bm)
+        );
+
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            ePatch,
+            dictionary,
+            (
+                const word& name,
+                const dictionary& dict,
+                const label index,
+                const eBoundaryMesh& bm
+            ),
+            (name, dict, index, bm)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        ePatch
+        (
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const eBoundaryMesh& bm
+        );
+
+
+        //- Construct from dictionary
+        ePatch
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const eBoundaryMesh& bm
+        );
+
+        //- Construct as copy, resetting the boundary mesh
+        ePatch(const ePatch&, const eBoundaryMesh&);
+
+
+    // Selectors
+
+        //- Return a pointer to a new patch created on freestore from
+        //  components
+        static autoPtr<ePatch> New
+        (
+            const word& patchType,
+            const word& name,
+            const label size,
+            const label start,
+            const label index,
+            const eBoundaryMesh& bm
+        );
+
+
+        //- Return a pointer to a new patch created 
+        // on freestore from dictionary
+        static autoPtr<ePatch> New
+        (
+            const word& name,
+            const dictionary& dict,
+            const label index,
+            const eBoundaryMesh& bm
+        );
+
+
+    // Destructor
+
+        virtual ~ePatch();
+
+
+    // Member Functions
+
+        //- Return the index of this patch in the boundaryMesh
+        label index() const
+        {
+            return patchIdentifier::index();
+        }
+
+        //- Return boundaryMesh reference
+        const eBoundaryMesh& boundaryMesh() const;
+
+        //- Return true if this patch is coupled
+        virtual bool coupled() const
+        {
+            return false;
+        }
+
+        //- Patch start in edge list
+        label start() const
+        {
+            return start_;
+        }
+
+        //- Patch size
+        virtual label size() const
+        {
+            return size_;
+        }
+
+        //- Slice list to patch
+        template<class T>
+        typename List<T>::subList patchSlice(const List<T>& l) const
+        {
+            return typename List<T>::subList(l, size(), start());
+        }
+
+        //- Write
+        virtual void write(Ostream&) const;
+
+        //- Assignment operator
+        void operator=(const ePatch&);
+
+
+    // Ostream Operator
+
+        friend Ostream& operator<<(Ostream&, const ePatch&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatchList.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatchList.H
new file mode 100644
index 000000000..498dbc1f5
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/ePatchList.H
@@ -0,0 +1,56 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Type
+    ePatchList
+
+Description
+    Container classes for ePatch
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ePatchList_H
+#define ePatchList_H
+
+#include "ePatch.H"
+#include "PtrList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+typedef PtrList<ePatch> ePatchList;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C
new file mode 100644
index 000000000..5e047effe
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/eMesh/ePatches/ePatch/newEPatch.C
@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "ePatch.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+autoPtr<ePatch> ePatch::New
+(
+    const word& patchType,
+    const word& name,
+    const label size,
+    const label start,
+    const label index,
+    const eBoundaryMesh& bm
+)
+{
+    if (debug)
+    {
+        Info<< "ePatch::New(const word&, const word&, const label, "
+               "const label, const label, const eBoundaryMesh&) : "
+               "constructing ePatch"
+            << endl;
+    }
+
+    wordConstructorTable::iterator cstrIter =
+        wordConstructorTablePtr_->find(patchType);
+
+    if (cstrIter == wordConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "ePatch::New(const word&, const word&, const label, "
+            "const label, const label, const eBoundaryMesh&) "
+        )   << "Unknown ePatch type " << patchType << " for patch " << name
+            << endl << endl
+            << "Valid ePatch types are :" << endl
+            << wordConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<ePatch>(cstrIter()(name, size, start, index, bm));
+}
+
+
+autoPtr<ePatch> ePatch::New
+(
+    const word& name,
+    const dictionary& dict,
+    const label index,
+    const eBoundaryMesh& bm
+)
+{
+    if (debug)
+    {
+        Info<< "ePatch::New(const word&, const dictionary&, const label, "
+               "const eBoundaryMesh&) : constructing ePatch"
+            << endl;
+    }
+
+    word patchType(dict.lookup("type"));
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(patchType);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalIOErrorIn
+        (
+            "ePatch::New(const word&, const dictionary&, "
+            "const label, const eBoundaryMesh&)",
+            dict
+        )   << "Unknown ePatch type " << patchType << endl << endl
+            << "Valid ePatch types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalIOError);
+    }
+
+    return autoPtr<ePatch>(cstrIter()(name, dict, index, bm));
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
new file mode 100644
index 000000000..bdb6e3cf2
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeBisect.C
@@ -0,0 +1,4852 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "Stack.H"
+#include "triFace.H"
+#include "objectMap.H"
+#include "changeMap.H"
+#include "multiThreader.H"
+#include "dynamicTopoFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Method for the bisection of a quad-face in 2D
+// - Returns a changeMap with a type specifying:
+//     1: Bisection was successful
+//    -1: Bisection failed since max number of topo-changes was reached.
+//    -2: Bisection failed since resulting quality would be unacceptable.
+const changeMap dynamicTopoFvMesh::bisectQuadFace
+(
+    const label fIndex,
+    const changeMap& masterMap,
+    bool checkOnly,
+    bool forceOp
+)
+{
+    // Quad-face bisection performs the following operations:
+    //      [1] Add two points at the middle of the face
+    //      [2] Create a new internal face for each bisected cell
+    //      [3] Modify existing face and create a new half-face
+    //      [4] Modify triangular boundary faces, and create new ones as well
+    //      [5] Create edges for new faces
+    //      Update faceEdges and edgeFaces information
+
+    // Figure out which thread this is...
+    label tIndex = self();
+
+    // Prepare the changeMaps
+    changeMap map, slaveMap;
+
+    if
+    (
+        (statistics_[0] > maxModifications_) &&
+        (maxModifications_ > -1)
+    )
+    {
+        // Reached the max allowable topo-changes.
+        stack(tIndex).clear();
+
+        return map;
+    }
+
+    // Check if edgeRefinements are to be avoided on patch.
+    if (lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
+    {
+        return map;
+    }
+
+    // Sanity check: Is the index legitimate?
+    if (fIndex < 0)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::bisectQuadFace\n"
+            "(\n"
+            "    const label fIndex,\n"
+            "    const changeMap& masterMap,\n"
+            "    bool checkOnly\n"
+            ")\n"
+        )
+            << " Invalid index: " << fIndex << nl
+            << " nFaces: " << nFaces_
+            << abort(FatalError);
+    }
+
+    bool found;
+    label replaceFace = -1, retainFace = -1;
+    face tmpQuadFace(4), tmpTriFace(3);
+    labelList tmpQFEdges(4, -1), tmpTFEdges(3, -1);
+    FixedList<label,7> newFaceIndex(-1), newEdgeIndex(-1);
+    FixedList<edge,4> commonEdges;
+    FixedList<label,4> cornerEdgeIndex(-1), commonEdgeIndex(-1);
+    FixedList<label,4> commonFaceIndex(-1);
+    FixedList<label,2> newPointIndex(-1), newCellIndex(-1);
+    FixedList<label,4> otherEdgeIndex(-1), otherEdgePoint(-1);
+    FixedList<label,4> otherPointIndex(-1), nextToOtherPoint(-1);
+    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
+    FixedList<face,2>  c0BdyFace,  c0IntFace,  c1BdyFace,  c1IntFace;
+
+    // Get the two cells on either side...
+    label c0 = owner_[fIndex], c1 = neighbour_[fIndex];
+
+    // Keep track of old / new cells
+    FixedList<cell, 2> oldCells(cell(5));
+    FixedList<cell, 2> newCells(cell(5));
+
+    // Find the prism faces for cell[0].
+    oldCells[0] = cells_[c0];
+
+    meshOps::findPrismFaces
+    (
+        fIndex,
+        c0,
+        faces_,
+        cells_,
+        neighbour_,
+        c0BdyFace,
+        c0BdyIndex,
+        c0IntFace,
+        c0IntIndex
+    );
+
+    // Check for resulting quality
+    if (checkBisection(fIndex, c0BdyIndex[0], forceOp))
+    {
+        map.type() = -2;
+        return map;
+    }
+
+    if (c1 != -1)
+    {
+        // Find the prism faces for cell[1].
+        meshOps::findPrismFaces
+        (
+            fIndex,
+            c1,
+            faces_,
+            cells_,
+            neighbour_,
+            c1BdyFace,
+            c1BdyIndex,
+            c1IntFace,
+            c1IntIndex
+        );
+
+        // Check for resulting quality
+        if (checkBisection(fIndex, c1BdyIndex[0], forceOp))
+        {
+            map.type() = -2;
+            return map;
+        }
+    }
+
+    if (debug > 1)
+    {
+        Info << nl << nl << "Face: " << fIndex
+             << ": " << faces_[fIndex] << " is to be bisected. " << endl;
+
+        label epIndex = whichPatch(fIndex);
+
+        Info << "Patch: ";
+
+        if (epIndex == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[epIndex].name() << endl;
+        }
+
+        if (debug > 2)
+        {
+            Info << "Cell[0]: " << c0 << ": " << oldCells[0] << endl;
+
+            forAll(oldCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[0][faceI]];
+
+                Info << oldCells[0][faceI] << ": "
+                     << faces_[oldCells[0][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+        }
+
+        // Write out VTK files prior to change
+        if (debug > 3)
+        {
+            labelList cellHull(2, -1);
+
+            cellHull[0] = owner_[fIndex];
+            cellHull[1] = neighbour_[fIndex];
+
+            writeVTK
+            (
+                Foam::name(fIndex)
+              + "_Bisect_0",
+                cellHull
+            );
+        }
+    }
+
+    // Find the common-edge between the triangular boundary faces
+    // and the face under consideration.
+    meshOps::findCommonEdge
+    (
+        c0BdyIndex[0],
+        fIndex,
+        faceEdges_,
+        commonEdgeIndex[0]
+    );
+
+    meshOps::findCommonEdge
+    (
+        c0BdyIndex[1],
+        fIndex,
+        faceEdges_,
+        commonEdgeIndex[1]
+    );
+
+    commonEdges[0] = edges_[commonEdgeIndex[0]];
+    commonEdges[1] = edges_[commonEdgeIndex[1]];
+
+    // Are we performing only checks?
+    if (checkOnly)
+    {
+        map.type() = 1;
+        return map;
+    }
+
+    // Find the isolated point on both boundary faces of cell[0]
+    meshOps::findIsolatedPoint
+    (
+        c0BdyFace[0],
+        commonEdges[0],
+        otherPointIndex[0],
+        nextToOtherPoint[0]
+    );
+
+    meshOps::findIsolatedPoint
+    (
+        c0BdyFace[1],
+        commonEdges[1],
+        otherPointIndex[1],
+        nextToOtherPoint[1]
+    );
+
+    // For convenience...
+    otherEdgePoint[0] = commonEdges[0].otherVertex(nextToOtherPoint[0]);
+    otherEdgePoint[1] = commonEdges[1].otherVertex(nextToOtherPoint[1]);
+
+    labelList mP(2, -1);
+
+    // Set mapping for this point
+    mP[0] = commonEdges[0][0];
+    mP[1] = commonEdges[0][1];
+
+    // Add two new points to the end of the list
+    newPointIndex[0] =
+    (
+        insertPoint
+        (
+            0.5 * (points_[mP[0]] + points_[mP[1]]),
+            0.5 * (oldPoints_[mP[0]] + oldPoints_[mP[1]]),
+            mP
+        )
+    );
+
+    // Set mapping for this point
+    mP[0] = commonEdges[1][0];
+    mP[1] = commonEdges[1][1];
+
+    newPointIndex[1] =
+    (
+        insertPoint
+        (
+            0.5 * (points_[mP[0]] + points_[mP[1]]),
+            0.5 * (oldPoints_[mP[0]] + oldPoints_[mP[1]]),
+            mP
+        )
+    );
+
+    {
+        map.addPoint(newPointIndex[0]);
+        map.addPoint(newPointIndex[1]);
+    }
+
+    // Add a new prism cell to the end of the list.
+    // Currently invalid, but will be updated later.
+    newCellIndex[0] = insertCell(newCells[0], lengthScale_[c0]);
+
+    // Modify the two existing triangle boundary faces
+
+    // Zeroth boundary face - Owner = c[0] & Neighbour [-1] (unchanged)
+    meshOps::replaceLabel
+    (
+        otherEdgePoint[0],
+        newPointIndex[0],
+        c0BdyFace[0]
+    );
+
+    // First boundary face - Owner = newCell[0], Neighbour = -1
+    meshOps::replaceLabel
+    (
+        otherEdgePoint[1],
+        newPointIndex[1],
+        c0BdyFace[1]
+    );
+
+    // Update faces.
+    faces_[c0BdyIndex[0]] = c0BdyFace[0];
+    faces_[c0BdyIndex[1]] = c0BdyFace[1];
+
+    owner_[c0BdyIndex[1]] = newCellIndex[0];
+
+    meshOps::replaceLabel
+    (
+        c0BdyIndex[1],
+        -1,
+        oldCells[0]
+    );
+
+    // Detect edges other than commonEdges
+    const labelList& fEdges = faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        if
+        (
+            fEdges[edgeI] != commonEdgeIndex[0] &&
+            fEdges[edgeI] != commonEdgeIndex[1]
+        )
+        {
+            // Obtain a reference to this edge
+            const edge& eThis = edges_[fEdges[edgeI]];
+
+            if
+            (
+                eThis[0] == nextToOtherPoint[0]
+             || eThis[1] == nextToOtherPoint[0]
+            )
+            {
+                otherEdgeIndex[0] = fEdges[edgeI];
+            }
+            else
+            {
+                otherEdgeIndex[1] = fEdges[edgeI];
+            }
+        }
+    }
+
+    // Modify point-labels on the quad face under consideration
+    meshOps::replaceLabel
+    (
+        otherEdgePoint[0],
+        newPointIndex[0],
+        faces_[fIndex]
+    );
+
+    meshOps::replaceLabel
+    (
+        nextToOtherPoint[1],
+        newPointIndex[1],
+        faces_[fIndex]
+    );
+
+    // Add this face to the map.
+    // Although this face isn't technically 'added', it's
+    // required for coupled patch mapping.
+    map.addFace(fIndex);
+
+    if (debug > 1)
+    {
+        Info << "Modified face: " << fIndex
+             << ": " << faces_[fIndex] << endl;
+
+        if (debug > 2)
+        {
+            Info << "Common edges: " << nl
+                 << commonEdgeIndex[0] << ": " << commonEdges[0] << nl
+                 << commonEdgeIndex[1] << ": " << commonEdges[1]
+                 << endl;
+        }
+    }
+
+    // Find the quad face that contains otherEdgeIndex[1]
+    found = false;
+
+    const labelList& e1 = faceEdges_[c0IntIndex[0]];
+
+    forAll(e1, edgeI)
+    {
+        if (e1[edgeI] == otherEdgeIndex[1])
+        {
+            meshOps::replaceLabel
+            (
+                c0IntIndex[0],
+                -1,
+                oldCells[0]
+            );
+
+            replaceFace = c0IntIndex[0];
+            retainFace = c0IntIndex[1];
+            found = true;
+            break;
+        }
+    }
+
+    if (!found)
+    {
+        // The edge was not found before
+        meshOps::replaceLabel
+        (
+            c0IntIndex[1],
+            -1,
+            oldCells[0]
+        );
+
+        replaceFace = c0IntIndex[1];
+        retainFace = c0IntIndex[0];
+    }
+
+    // Check if face reversal is necessary for the replacement
+    if (owner_[replaceFace] == c0)
+    {
+        if (neighbour_[replaceFace] == -1)
+        {
+            // Change the owner
+            owner_[replaceFace] = newCellIndex[0];
+        }
+        else
+        {
+            // This face has to be reversed
+            faces_[replaceFace] = faces_[replaceFace].reverseFace();
+            owner_[replaceFace] = neighbour_[replaceFace];
+            neighbour_[replaceFace] = newCellIndex[0];
+
+            setFlip(replaceFace);
+        }
+    }
+    else
+    {
+        // Keep owner, but change neighbour
+        neighbour_[replaceFace] = newCellIndex[0];
+    }
+
+    // Define the faces for the new cell
+    newCells[0][0] = c0BdyIndex[1];
+    newCells[0][1] = replaceFace;
+
+    // Define the set of new faces and insert...
+
+    // New interior face; Owner = cell[0] & Neighbour = newCell[0]
+    tmpQuadFace[0] = otherPointIndex[0];
+    tmpQuadFace[1] = newPointIndex[0];
+    tmpQuadFace[2] = newPointIndex[1];
+    tmpQuadFace[3] = otherPointIndex[1];
+
+    newFaceIndex[0] =
+    (
+        insertFace
+        (
+            -1,
+            tmpQuadFace,
+            c0,
+            newCellIndex[0]
+        )
+    );
+
+    // Add a faceEdges entry as well
+    faceEdges_.append(tmpQFEdges);
+
+    // Find the common edge between quad/quad faces...
+    meshOps::findCommonEdge
+    (
+        c0IntIndex[0],
+        c0IntIndex[1],
+        faceEdges_,
+        otherEdgeIndex[2]
+    );
+
+    // ... and size-up edgeFaces for the edge
+    meshOps::sizeUpList
+    (
+        newFaceIndex[0],
+        edgeFaces_[otherEdgeIndex[2]]
+    );
+
+    meshOps::replaceLabel
+    (
+        -1,
+        newFaceIndex[0],
+        newCells[0]
+    );
+
+    meshOps::replaceLabel
+    (
+        -1,
+        newFaceIndex[0],
+        oldCells[0]
+    );
+
+    // remove2DSliver requires this face index for removal
+    map.addFace(newFaceIndex[0]);
+
+    // Second boundary face; Owner = newCell[0] & Neighbour = [-1]
+    tmpTriFace[0] = otherPointIndex[0];
+    tmpTriFace[1] = newPointIndex[0];
+    tmpTriFace[2] = otherEdgePoint[0];
+
+    newFaceIndex[1] =
+    (
+        insertFace
+        (
+            whichPatch(c0BdyIndex[0]),
+            tmpTriFace,
+            newCellIndex[0],
+            -1
+        )
+    );
+
+    // Add a faceEdges entry as well
+    faceEdges_.append(tmpTFEdges);
+
+    meshOps::replaceLabel
+    (
+        -1,
+        newFaceIndex[1],
+        newCells[0]
+    );
+
+    // Third boundary face; Owner = c[0] & Neighbour = [-1]
+    tmpTriFace[0] = otherPointIndex[1];
+    tmpTriFace[1] = newPointIndex[1];
+    tmpTriFace[2] = otherEdgePoint[1];
+
+    newFaceIndex[2] =
+    (
+        insertFace
+        (
+            whichPatch(c0BdyIndex[1]),
+            tmpTriFace,
+            c0,
+            -1
+        )
+    );
+
+    // Add a faceEdges entry as well
+    faceEdges_.append(tmpTFEdges);
+
+    meshOps::replaceLabel
+    (
+        -1,
+        newFaceIndex[2],
+        oldCells[0]
+    );
+
+    // Create / modify edges...
+    labelList tmpTriEdgeFaces(3, -1);
+
+    // The edge bisecting the zeroth boundary triangular face
+    tmpTriEdgeFaces[0] = c0BdyIndex[0];
+    tmpTriEdgeFaces[1] = newFaceIndex[0];
+    tmpTriEdgeFaces[2] = newFaceIndex[1];
+
+    newEdgeIndex[1] =
+    (
+        insertEdge
+        (
+            whichEdgePatch(commonEdgeIndex[0]),
+            edge(newPointIndex[0], otherPointIndex[0]),
+            tmpTriEdgeFaces
+        )
+    );
+
+    // Find the common edge between the quad/tri faces...
+    meshOps::findCommonEdge
+    (
+        c0BdyIndex[0],
+        replaceFace,
+        faceEdges_,
+        cornerEdgeIndex[0]
+    );
+
+    // ...and correct faceEdges / edgeFaces
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[0],
+        newEdgeIndex[1],
+        faceEdges_[c0BdyIndex[0]]
+    );
+
+    meshOps::replaceLabel
+    (
+        c0BdyIndex[0],
+        newFaceIndex[1],
+        edgeFaces_[cornerEdgeIndex[0]]
+    );
+
+    // The edge bisecting the first boundary triangular face
+    tmpTriEdgeFaces[0] = c0BdyIndex[1];
+    tmpTriEdgeFaces[1] = newFaceIndex[0];
+    tmpTriEdgeFaces[2] = newFaceIndex[2];
+
+    newEdgeIndex[2] =
+    (
+        insertEdge
+        (
+            whichEdgePatch(commonEdgeIndex[1]),
+            edge(newPointIndex[1], otherPointIndex[1]),
+            tmpTriEdgeFaces
+        )
+    );
+
+    // Find the common edge between the quad/tri faces...
+    meshOps::findCommonEdge
+    (
+        c0BdyIndex[1],
+        retainFace,
+        faceEdges_,
+        cornerEdgeIndex[1]
+    );
+
+    // ...and correct faceEdges / edgeFaces
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[1],
+        newEdgeIndex[2],
+        faceEdges_[c0BdyIndex[1]]
+    );
+
+    meshOps::replaceLabel
+    (
+        c0BdyIndex[1],
+        newFaceIndex[2],
+        edgeFaces_[cornerEdgeIndex[1]]
+    );
+
+    if (c1 == -1)
+    {
+        // The quad boundary face resulting from bisection;
+        // Owner = newCell[0] & Neighbour = [-1]
+        tmpQuadFace[0] = newPointIndex[1];
+        tmpQuadFace[1] = nextToOtherPoint[1];
+        tmpQuadFace[2] = otherEdgePoint[0];
+        tmpQuadFace[3] = newPointIndex[0];
+
+        newFaceIndex[3] =
+        (
+            insertFace
+            (
+                whichPatch(fIndex),
+                tmpQuadFace,
+                newCellIndex[0],
+                -1
+            )
+        );
+
+        // Add this face to the map.
+        map.addFace(newFaceIndex[3]);
+
+        // Add a faceEdges entry as well
+        faceEdges_.append(tmpQFEdges);
+
+        // Correct edgeFaces for otherEdgeIndex[1]
+        meshOps::replaceLabel
+        (
+            fIndex,
+            newFaceIndex[3],
+            edgeFaces_[otherEdgeIndex[1]]
+        );
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[3],
+            newCells[0]
+        );
+
+        labelList tmpBiEdgeFaces(2, -1);
+
+        // The edge bisecting the face
+        tmpTriEdgeFaces[0] = newFaceIndex[3];
+        tmpTriEdgeFaces[1] = newFaceIndex[0];
+        tmpTriEdgeFaces[2] = fIndex;
+
+        newEdgeIndex[0] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(otherEdgeIndex[0]),
+                edge(newPointIndex[0], newPointIndex[1]),
+                tmpTriEdgeFaces
+            )
+        );
+
+        // Replace an edge on the bisected face
+        meshOps::replaceLabel
+        (
+            otherEdgeIndex[1],
+            newEdgeIndex[0],
+            faceEdges_[fIndex]
+        );
+
+        // Create / replace side edges created from face bisection
+        tmpBiEdgeFaces[0] = newFaceIndex[1];
+        tmpBiEdgeFaces[1] = newFaceIndex[3];
+
+        newEdgeIndex[3] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[0]),
+                edge(newPointIndex[0], otherEdgePoint[0]),
+                tmpBiEdgeFaces
+            )
+        );
+
+        tmpBiEdgeFaces[0] = c0BdyIndex[1];
+        tmpBiEdgeFaces[1] = newFaceIndex[3];
+
+        newEdgeIndex[4] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[1]),
+                edge(newPointIndex[1], nextToOtherPoint[1]),
+                tmpBiEdgeFaces
+            )
+        );
+
+        // Now that edges are defined, configure faceEdges
+        // for all new faces
+
+        // The quad interior face; Owner = cell[0] & Neighbour = newCell[0]
+        tmpQFEdges[0] = newEdgeIndex[0];
+        tmpQFEdges[1] = newEdgeIndex[1];
+        tmpQFEdges[2] = otherEdgeIndex[2];
+        tmpQFEdges[3] = newEdgeIndex[2];
+        faceEdges_[newFaceIndex[0]] = tmpQFEdges;
+
+        // Second boundary face; Owner = newCell[0] & Neighbour = [-1]
+        tmpTFEdges[0] = newEdgeIndex[3];
+        tmpTFEdges[1] = cornerEdgeIndex[0];
+        tmpTFEdges[2] = newEdgeIndex[1];
+        faceEdges_[newFaceIndex[1]] = tmpTFEdges;
+
+        // Third boundary face; Owner = c[0] & Neighbour = [-1]
+        tmpTFEdges[0] = newEdgeIndex[2];
+        tmpTFEdges[1] = cornerEdgeIndex[1];
+        tmpTFEdges[2] = commonEdgeIndex[1];
+        faceEdges_[newFaceIndex[2]] = tmpTFEdges;
+
+        // The quad face from bisection:
+        tmpQFEdges[0] = otherEdgeIndex[1];
+        tmpQFEdges[1] = newEdgeIndex[3];
+        tmpQFEdges[2] = newEdgeIndex[0];
+        tmpQFEdges[3] = newEdgeIndex[4];
+        faceEdges_[newFaceIndex[3]] = tmpQFEdges;
+
+        meshOps::replaceLabel
+        (
+            commonEdgeIndex[1],
+            newEdgeIndex[4],
+            faceEdges_[c0BdyIndex[1]]
+        );
+
+        meshOps::replaceLabel
+        (
+            c0BdyIndex[1],
+            newFaceIndex[2],
+            edgeFaces_[commonEdgeIndex[1]]
+        );
+
+        if (debug > 2)
+        {
+            Info << "Modified Cell[0]: "
+                 << c0 << ": " << oldCells[0] << endl;
+
+            forAll(oldCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[0][faceI]];
+
+                Info << oldCells[0][faceI]
+                     << ": " << faces_[oldCells[0][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+
+            Info << "New Cell[0]: " << newCellIndex[0]
+                 << ": " << newCells[0] << endl;
+
+            forAll(newCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[newCells[0][faceI]];
+
+                Info << newCells[0][faceI]
+                     << ": " << faces_[newCells[0][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+        }
+    }
+    else
+    {
+        oldCells[1] = cells_[c1];
+
+        newCellIndex[1] = insertCell(newCells[1], lengthScale_[c1]);
+
+        if (debug > 2)
+        {
+            Info << "Cell[1]: " << c1 << ": " << oldCells[1] << endl;
+
+            forAll(oldCells[1], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[1][faceI]];
+
+                Info << oldCells[1][faceI] << ": "
+                     << faces_[oldCells[1][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+        }
+
+        // Find the interior face that contains otherEdgeIndex[1]
+        found = false;
+
+        const labelList& e2 = faceEdges_[c1IntIndex[0]];
+
+        forAll(e2, edgeI)
+        {
+            if (e2[edgeI] == otherEdgeIndex[1])
+            {
+                meshOps::replaceLabel
+                (
+                    c1IntIndex[0],
+                    -1,
+                    oldCells[1]
+                );
+
+                replaceFace = c1IntIndex[0];
+                retainFace = c1IntIndex[1];
+                found = true;
+                break;
+            }
+        }
+
+        if (!found)
+        {
+            // The edge was not found before
+            meshOps::replaceLabel
+            (
+                c1IntIndex[1],
+                -1,
+                oldCells[1]
+            );
+
+            replaceFace = c1IntIndex[1];
+            retainFace = c1IntIndex[0];
+        }
+
+        // Check if face reversal is necessary for the replacement
+        if (owner_[replaceFace] == c1)
+        {
+            if (neighbour_[replaceFace] == -1)
+            {
+                // Change the owner
+                owner_[replaceFace] = newCellIndex[1];
+            }
+            else
+            {
+                // This face has to be reversed
+                faces_[replaceFace] = faces_[replaceFace].reverseFace();
+                owner_[replaceFace] = neighbour_[replaceFace];
+                neighbour_[replaceFace] = newCellIndex[1];
+
+                setFlip(replaceFace);
+            }
+        }
+        else
+        {
+            // Keep owner, but change neighbour
+            neighbour_[replaceFace] = newCellIndex[1];
+        }
+
+        // Define attributes for the new prism cell
+        newCells[1][0] = replaceFace;
+
+        // The quad interior face resulting from bisection;
+        // Owner = newCell[0] & Neighbour = newCell[1]
+        tmpQuadFace[0] = newPointIndex[1];
+        tmpQuadFace[1] = nextToOtherPoint[1];
+        tmpQuadFace[2] = otherEdgePoint[0];
+        tmpQuadFace[3] = newPointIndex[0];
+
+        newFaceIndex[3] =
+        (
+            insertFace
+            (
+                -1,
+                tmpQuadFace,
+                newCellIndex[0],
+                newCellIndex[1]
+            )
+        );
+
+        // Add a faceEdges entry as well
+        faceEdges_.append(tmpQFEdges);
+
+        // Correct edgeFaces for otherEdgeIndex[1]
+        meshOps::replaceLabel
+        (
+            fIndex,
+            newFaceIndex[3],
+            edgeFaces_[otherEdgeIndex[1]]
+        );
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[3],
+            newCells[0]
+        );
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[3],
+            newCells[1]
+        );
+
+        newCells[1][1] = newFaceIndex[3];
+
+        // Check for common edges among the two boundary faces
+        // Find the isolated point on both boundary faces of cell[1]
+        if
+        (
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                c0BdyIndex[0],
+                faceEdges_,
+                commonEdgeIndex[2]
+            )
+        )
+        {
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                c0BdyIndex[1],
+                faceEdges_,
+                commonEdgeIndex[3]
+            );
+
+            commonFaceIndex[2] = c1BdyIndex[0];
+            commonFaceIndex[3] = c1BdyIndex[1];
+        }
+        else
+        {
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                c0BdyIndex[1],
+                faceEdges_,
+                commonEdgeIndex[3]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                c0BdyIndex[0],
+                faceEdges_,
+                commonEdgeIndex[2]
+            );
+
+            commonFaceIndex[2] = c1BdyIndex[1];
+            commonFaceIndex[3] = c1BdyIndex[0];
+        }
+
+        commonEdges[2] = edges_[commonEdgeIndex[2]];
+        commonEdges[3] = edges_[commonEdgeIndex[3]];
+
+        if (debug > 2)
+        {
+            Info << "Common edges: " << nl
+                 << commonEdgeIndex[2] << ": " << commonEdges[2] << nl
+                 << commonEdgeIndex[3] << ": " << commonEdges[3]
+                 << endl;
+        }
+
+        meshOps::findIsolatedPoint
+        (
+            faces_[commonFaceIndex[2]],
+            commonEdges[2],
+            otherPointIndex[2],
+            nextToOtherPoint[2]
+        );
+
+        meshOps::findIsolatedPoint
+        (
+            faces_[commonFaceIndex[3]],
+            commonEdges[3],
+            otherPointIndex[3],
+            nextToOtherPoint[3]
+        );
+
+        // For convenience...
+        otherEdgePoint[2] = commonEdges[2].otherVertex(nextToOtherPoint[2]);
+        otherEdgePoint[3] = commonEdges[3].otherVertex(nextToOtherPoint[3]);
+
+        // Modify the two existing triangle boundary faces
+
+        // Zeroth boundary face - Owner = newCell[1], Neighbour = -1
+        meshOps::replaceLabel
+        (
+            otherEdgePoint[2],
+            newPointIndex[0],
+            faces_[commonFaceIndex[2]]
+        );
+
+        owner_[commonFaceIndex[2]] = newCellIndex[1];
+
+        meshOps::replaceLabel
+        (
+            commonFaceIndex[2],
+            -1,
+            oldCells[1]
+        );
+
+        newCells[1][2] = commonFaceIndex[2];
+
+        // First boundary face - Owner = c[1] & Neighbour [-1] (unchanged)
+        meshOps::replaceLabel
+        (
+            otherEdgePoint[3],
+            newPointIndex[1],
+            faces_[commonFaceIndex[3]]
+        );
+
+        // New interior face; Owner = cell[1] & Neighbour = newCell[1]
+        tmpQuadFace[0] = newPointIndex[0];
+        tmpQuadFace[1] = otherPointIndex[2];
+        tmpQuadFace[2] = otherPointIndex[3];
+        tmpQuadFace[3] = newPointIndex[1];
+
+        newFaceIndex[4] =
+        (
+            insertFace
+            (
+                -1,
+                tmpQuadFace,
+                c1,
+                newCellIndex[1]
+            )
+        );
+
+        // Add a faceEdges entry as well
+        faceEdges_.append(tmpQFEdges);
+
+        // remove2DSliver requires this face index for removal
+        map.addFace(newFaceIndex[4]);
+
+        // Find the common edge between quad/quad faces...
+        meshOps::findCommonEdge
+        (
+            c1IntIndex[0],
+            c1IntIndex[1],
+            faceEdges_,
+            otherEdgeIndex[3]
+        );
+
+        // ... and size-up edgeFaces for the edge
+        meshOps::sizeUpList
+        (
+            newFaceIndex[4],
+            edgeFaces_[otherEdgeIndex[3]]
+        );
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[4],
+            newCells[1]
+        );
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[4],
+            oldCells[1]
+        );
+
+        // Second boundary face; Owner = cell[1] & Neighbour [-1]
+        tmpTriFace[0] = otherPointIndex[2];
+        tmpTriFace[1] = newPointIndex[0];
+        tmpTriFace[2] = otherEdgePoint[2];
+
+        newFaceIndex[5] =
+        (
+            insertFace
+            (
+                whichPatch(commonFaceIndex[2]),
+                tmpTriFace,
+                c1,
+                -1
+            )
+        );
+
+        // Add a faceEdges entry as well
+        faceEdges_.append(tmpTFEdges);
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[5],
+            oldCells[1]
+        );
+
+        // Third boundary face; Owner = newCell[1] & Neighbour [-1]
+        tmpTriFace[0] = otherPointIndex[3];
+        tmpTriFace[1] = newPointIndex[1];
+        tmpTriFace[2] = otherEdgePoint[3];
+
+        newFaceIndex[6] =
+        (
+            insertFace
+            (
+                whichPatch(commonFaceIndex[3]),
+                tmpTriFace,
+                newCellIndex[1],
+                -1
+            )
+        );
+
+        // Add a faceEdges entry as well
+        faceEdges_.append(tmpTFEdges);
+
+        meshOps::replaceLabel
+        (
+            -1,
+            newFaceIndex[6],
+            newCells[1]
+        );
+
+        // Create / modify edges...
+        labelList tmpQuadEdgeFaces(4, -1);
+
+        // The internal edge bisecting the face
+        tmpQuadEdgeFaces[0] = fIndex;
+        tmpQuadEdgeFaces[1] = newFaceIndex[0];
+        tmpQuadEdgeFaces[2] = newFaceIndex[3];
+        tmpQuadEdgeFaces[3] = newFaceIndex[4];
+
+        newEdgeIndex[0] =
+        (
+            insertEdge
+            (
+                -1,
+                edge(newPointIndex[0], newPointIndex[1]),
+                tmpQuadEdgeFaces
+            )
+        );
+
+        // Replace an edge on the bisected face
+        meshOps::replaceLabel
+        (
+            otherEdgeIndex[1],
+            newEdgeIndex[0],
+            faceEdges_[fIndex]
+        );
+
+        // Create / replace side edges created from face bisection
+        tmpTriEdgeFaces[0] = commonFaceIndex[2];
+        tmpTriEdgeFaces[1] = newFaceIndex[3];
+        tmpTriEdgeFaces[2] = newFaceIndex[1];
+
+        newEdgeIndex[3] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[2]),
+                edge(newPointIndex[0], nextToOtherPoint[2]),
+                tmpTriEdgeFaces
+            )
+        );
+
+        tmpTriEdgeFaces[0] = c0BdyIndex[1];
+        tmpTriEdgeFaces[1] = newFaceIndex[3];
+        tmpTriEdgeFaces[2] = newFaceIndex[6];
+
+        newEdgeIndex[4] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[3]),
+                edge(newPointIndex[1], otherEdgePoint[3]),
+                tmpTriEdgeFaces
+            )
+        );
+
+        // The edge bisecting the second boundary triangular face
+        tmpTriEdgeFaces[0] = commonFaceIndex[2];
+        tmpTriEdgeFaces[1] = newFaceIndex[4];
+        tmpTriEdgeFaces[2] = newFaceIndex[5];
+
+        newEdgeIndex[5] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[2]),
+                edge(newPointIndex[0], otherPointIndex[2]),
+                tmpTriEdgeFaces
+            )
+        );
+
+        // Find the common edge between the quad/tri faces...
+        meshOps::findCommonEdge
+        (
+            commonFaceIndex[2],
+            retainFace,
+            faceEdges_,
+            cornerEdgeIndex[2]
+        );
+
+        // ...and correct faceEdges / edgeFaces
+        meshOps::replaceLabel
+        (
+            cornerEdgeIndex[2],
+            newEdgeIndex[5],
+            faceEdges_[commonFaceIndex[2]]
+        );
+
+        meshOps::replaceLabel
+        (
+            commonFaceIndex[2],
+            newFaceIndex[5],
+            edgeFaces_[cornerEdgeIndex[2]]
+        );
+
+        // The edge bisecting the third boundary triangular face
+        tmpTriEdgeFaces[0] = commonFaceIndex[3];
+        tmpTriEdgeFaces[1] = newFaceIndex[4];
+        tmpTriEdgeFaces[2] = newFaceIndex[6];
+
+        newEdgeIndex[6] =
+        (
+            insertEdge
+            (
+                whichEdgePatch(commonEdgeIndex[3]),
+                edge(newPointIndex[1], otherPointIndex[3]),
+                tmpTriEdgeFaces
+            )
+        );
+
+        // Find the common edge between the quad/tri faces...
+        meshOps::findCommonEdge
+        (
+            commonFaceIndex[3],
+            replaceFace,
+            faceEdges_,
+            cornerEdgeIndex[3]
+        );
+
+        // ...and correct faceEdges / edgeFaces
+        meshOps::replaceLabel
+        (
+            cornerEdgeIndex[3],
+            newEdgeIndex[6],
+            faceEdges_[commonFaceIndex[3]]
+        );
+
+        meshOps::replaceLabel
+        (
+            commonFaceIndex[3],
+            newFaceIndex[6],
+            edgeFaces_[cornerEdgeIndex[3]]
+        );
+
+        // Now that edges are defined, configure faceEdges
+        // for all new faces
+
+        // The quad interior face; Owner = c[0] & Neighbour = newCell[0]
+        tmpQFEdges[0] = newEdgeIndex[0];
+        tmpQFEdges[1] = newEdgeIndex[1];
+        tmpQFEdges[2] = otherEdgeIndex[2];
+        tmpQFEdges[3] = newEdgeIndex[2];
+        faceEdges_[newFaceIndex[0]] = tmpQFEdges;
+
+        // Second boundary face; Owner = newCell[0] & Neighbour = [-1]
+        tmpTFEdges[0] = newEdgeIndex[3];
+        tmpTFEdges[1] = cornerEdgeIndex[0];
+        tmpTFEdges[2] = newEdgeIndex[1];
+        faceEdges_[newFaceIndex[1]] = tmpTFEdges;
+
+        // Third boundary face; Owner = c[0] & Neighbour = [-1]
+        tmpTFEdges[0] = newEdgeIndex[2];
+        tmpTFEdges[1] = cornerEdgeIndex[1];
+        tmpTFEdges[2] = commonEdgeIndex[3];
+        faceEdges_[newFaceIndex[2]] = tmpTFEdges;
+
+        // The quad face from bisection:
+        tmpQFEdges[0] = otherEdgeIndex[1];
+        tmpQFEdges[1] = newEdgeIndex[3];
+        tmpQFEdges[2] = newEdgeIndex[0];
+        tmpQFEdges[3] = newEdgeIndex[4];
+        faceEdges_[newFaceIndex[3]] = tmpQFEdges;
+
+        // The quad interior face; Owner = c[1] & Neighbour = newCell[1]
+        tmpQFEdges[0] = newEdgeIndex[0];
+        tmpQFEdges[1] = newEdgeIndex[5];
+        tmpQFEdges[2] = otherEdgeIndex[3];
+        tmpQFEdges[3] = newEdgeIndex[6];
+        faceEdges_[newFaceIndex[4]] = tmpQFEdges;
+
+        // Second boundary face; Owner = c[1] & Neighbour = [-1]
+        tmpTFEdges[0] = commonEdgeIndex[2];
+        tmpTFEdges[1] = cornerEdgeIndex[2];
+        tmpTFEdges[2] = newEdgeIndex[5];
+        faceEdges_[newFaceIndex[5]] = tmpTFEdges;
+
+        // Third boundary face; Owner = newCell[1] & Neighbour = [-1]
+        tmpTFEdges[0] = newEdgeIndex[4];
+        tmpTFEdges[1] = cornerEdgeIndex[3];
+        tmpTFEdges[2] = newEdgeIndex[6];
+        faceEdges_[newFaceIndex[6]] = tmpTFEdges;
+
+        meshOps::replaceLabel
+        (
+            commonEdgeIndex[1],
+            newEdgeIndex[4],
+            faceEdges_[c0BdyIndex[1]]
+        );
+
+        meshOps::replaceLabel
+        (
+            c0BdyIndex[1],
+            newFaceIndex[2],
+            edgeFaces_[commonEdgeIndex[1]]
+        );
+
+        meshOps::replaceLabel
+        (
+            commonEdgeIndex[2],
+            newEdgeIndex[3],
+            faceEdges_[commonFaceIndex[2]]
+        );
+
+        meshOps::replaceLabel
+        (
+            commonFaceIndex[2],
+            newFaceIndex[5],
+            edgeFaces_[commonEdgeIndex[2]]
+        );
+
+        if (debug > 2)
+        {
+            Info << nl << "Modified Cell[0]: "
+                 << c0 << ": " << oldCells[0] << endl;
+
+            forAll(oldCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[0][faceI]];
+
+                Info << oldCells[0][faceI]
+                     << ": " << faces_[oldCells[0][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+
+            Info << "New Cell[0]: "
+                 << newCellIndex[0] << ": " << newCells[0] << endl;
+
+            forAll(newCells[0], faceI)
+            {
+                const labelList& fE = faceEdges_[newCells[0][faceI]];
+
+                Info << newCells[0][faceI] << ": "
+                     << faces_[newCells[0][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+
+            Info << nl << "Modified Cell[1]: "
+                 << c1 << ": " << oldCells[1] << endl;
+
+            forAll(oldCells[1], faceI)
+            {
+                const labelList& fE = faceEdges_[oldCells[1][faceI]];
+
+                Info << oldCells[1][faceI] << ": "
+                     << faces_[oldCells[1][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+
+            Info << "New Cell[1]: "
+                 << newCellIndex[1] << ": " << newCells[1] << endl;
+
+            forAll(newCells[1], faceI)
+            {
+                const labelList& fE = faceEdges_[newCells[1][faceI]];
+
+                Info << newCells[1][faceI] << ": "
+                     << faces_[newCells[1][faceI]]
+                     << " fE: " << fE
+                     << endl;
+
+                forAll(fE, edgeI)
+                {
+                    const labelList& eF = edgeFaces_[fE[edgeI]];
+
+                    Info << '\t' << fE[edgeI]
+                         << ": " << edges_[fE[edgeI]]
+                         << " eF: " << eF
+                         << endl;
+                }
+            }
+        }
+
+        // Update the cell list.
+        cells_[c1] = oldCells[1];
+        cells_[newCellIndex[1]] = newCells[1];
+    }
+
+    // Update the cell list.
+    cells_[c0] = oldCells[0];
+    cells_[newCellIndex[0]] = newCells[0];
+
+    // Modify point labels for common edges
+    if (edges_[commonEdgeIndex[0]].start() == otherEdgePoint[0])
+    {
+        edges_[commonEdgeIndex[0]].start() = newPointIndex[0];
+    }
+    else
+    {
+        edges_[commonEdgeIndex[0]].end() = newPointIndex[0];
+    }
+
+    if (edges_[commonEdgeIndex[1]].start() == nextToOtherPoint[1])
+    {
+        edges_[commonEdgeIndex[1]].start() = newPointIndex[1];
+    }
+    else
+    {
+        edges_[commonEdgeIndex[1]].end() = newPointIndex[1];
+    }
+
+    // Write out VTK files after change
+    if (debug > 3)
+    {
+        labelList cellHull(4, -1);
+
+        cellHull[0] = owner_[fIndex];
+        cellHull[1] = neighbour_[fIndex];
+        cellHull[2] = owner_[newFaceIndex[3]];
+        cellHull[3] = neighbour_[newFaceIndex[3]];
+
+        writeVTK
+        (
+            Foam::name(fIndex)
+          + "_Bisect_1",
+            cellHull
+        );
+    }
+
+    // Fill-in mapping information
+    FixedList<label, 4> mapCells(-1);
+
+    mapCells[0] = c0;
+    mapCells[1] = newCellIndex[0];
+
+    if (c1 != -1)
+    {
+        mapCells[2] = c1;
+        mapCells[3] = newCellIndex[1];
+    }
+
+    labelList mC(1, c0);
+
+    forAll(mapCells, cellI)
+    {
+        if (mapCells[cellI] == -1)
+        {
+            continue;
+        }
+
+        // Set the mapping for this cell
+        setCellMapping(mapCells[cellI], mC);
+    }
+
+    // Set fill-in mapping information for the modified face.
+    if (c1 == -1)
+    {
+        // Set the mapping for this face
+        setFaceMapping(fIndex, labelList(1, fIndex));
+    }
+    else
+    {
+        // Internal face. Default mapping.
+        setFaceMapping(fIndex);
+    }
+
+    forAll(newFaceIndex, faceI)
+    {
+        if (newFaceIndex[faceI] == -1)
+        {
+            continue;
+        }
+
+        // Check for boundary faces
+        if (neighbour_[newFaceIndex[faceI]] == -1)
+        {
+            // Boundary face. Compute mapping.
+            labelList mC;
+
+            if (faces_[newFaceIndex[faceI]].size() == 4)
+            {
+                // Quad-face on boundary
+                mC.setSize(1, fIndex);
+            }
+            else
+            if (faces_[newFaceIndex[faceI]].size() == 3)
+            {
+                label triFacePatch = whichPatch(newFaceIndex[faceI]);
+
+                // Fetch face-normals
+                vector tfNorm, f0Norm, f1Norm;
+
+                meshOps::faceNormal
+                (
+                    faces_[newFaceIndex[faceI]],
+                    oldPoints_,
+                    tfNorm
+                );
+
+                meshOps::faceNormal
+                (
+                    faces_[c0BdyIndex[0]],
+                    oldPoints_,
+                    f0Norm
+                );
+
+                meshOps::faceNormal
+                (
+                    faces_[c0BdyIndex[1]],
+                    oldPoints_,
+                    f1Norm
+                );
+
+                // Tri-face on boundary. Perform normal checks
+                // also, because of empty patches.
+                if
+                (
+                    (whichPatch(c0BdyIndex[0]) == triFacePatch) &&
+                    ((tfNorm & f0Norm) > 0.0)
+                )
+                {
+                    mC.setSize(1, c0BdyIndex[0]);
+                }
+                else
+                if
+                (
+                    (whichPatch(c0BdyIndex[1]) == triFacePatch) &&
+                    ((tfNorm & f1Norm) > 0.0)
+                )
+                {
+                    mC.setSize(1, c0BdyIndex[1]);
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "\n"
+                        "const changeMap dynamicTopoFvMesh::bisectQuadFace\n"
+                        "(\n"
+                        "    const label fIndex,\n"
+                        "    const changeMap& masterMap,\n"
+                        "    bool checkOnly\n"
+                        ")\n"
+                    )
+                        << " Unable to find patch for face: "
+                        << newFaceIndex[faceI] << ":: "
+                        << faces_[newFaceIndex[faceI]] << nl
+                        << " Patch: " << triFacePatch << nl
+                        << abort(FatalError);
+                }
+            }
+
+            // Set the mapping for this face
+            setFaceMapping(newFaceIndex[faceI], mC);
+        }
+        else
+        {
+            // Internal quad-faces get default mapping.
+            setFaceMapping(newFaceIndex[faceI]);
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Increment the counter
+    statistics_[3]++;
+
+    // Increment surface-counter
+    if (c1 == -1)
+    {
+        statistics_[5]++;
+    }
+
+    // Increment the number of modifications
+    statistics_[0]++;
+
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+// Method for the bisection of an edge in 3D
+// - Returns a changeMap with a type specifying:
+//     1: Bisection was successful
+//    -1: Bisection failed since max number of topo-changes was reached.
+//    -2: Bisection failed since resulting quality would be unacceptable.
+// - AddedPoints contain the index of the newly added point.
+const changeMap dynamicTopoFvMesh::bisectEdge
+(
+    const label eIndex,
+    bool checkOnly,
+    bool forceOp
+)
+{
+    // Edge bisection performs the following operations:
+    //      [1] Add a point at middle of the edge
+    //      [2] Bisect all faces surrounding this edge
+    //      [3] Bisect all cells surrounding this edge
+    //      [4] Create internal/external edges for each bisected face
+    //      [5] Create internal faces for each bisected cell
+    //      Update faceEdges, edgeFaces and edgePoints information
+
+    // For 2D meshes, perform face-bisection
+    if (twoDMesh_)
+    {
+        return bisectQuadFace(eIndex, changeMap(), checkOnly);
+    }
+
+    // Figure out which thread this is...
+    label tIndex = self();
+
+    // Prepare the changeMaps
+    changeMap map, slaveMap;
+
+    if
+    (
+        (statistics_[0] > maxModifications_) &&
+        (maxModifications_ > -1)
+    )
+    {
+        // Reached the max allowable topo-changes.
+        stack(tIndex).clear();
+
+        return map;
+    }
+
+    // Check if edgeRefinements are to be avoided on patch.
+    if (lengthEstimator().checkRefinementPatch(whichEdgePatch(eIndex)))
+    {
+        return map;
+    }
+
+    // Sanity check: Is the index legitimate?
+    if (eIndex < 0)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::bisectEdge\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    bool checkOnly,\n"
+            "    bool forceOp\n"
+            ")\n"
+        )
+            << " Invalid index: " << eIndex
+            << " nEdges: " << nEdges_
+            << abort(FatalError);
+    }
+
+    // Before we bisect this edge, check whether the operation will
+    // yield an acceptable cell-quality.
+    scalar minQ = 0.0;
+
+    if ((minQ = computeBisectionQuality(eIndex)) < sliverThreshold_)
+    {
+        // Check if the quality is actually valid before forcing it.
+        if (forceOp && (minQ < 0.0))
+        {
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::bisectEdge\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << " Forcing bisection on edge: " << eIndex
+                << " 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 (whichEdgePatch(eIndex) > -1)
+    {
+        statistics_[5]++;
+    }
+
+    // Hull variables
+    face tmpTriFace(3);
+    labelList tmpEdgeFaces(3,-1);
+    labelList tmpIntEdgeFaces(4,-1);
+    labelList tmpEdgePoints(3,-1);
+    labelList tmpIntEdgePoints(4,-1);
+    labelList tmpFaceEdges(3,-1);
+
+    // Make a copy of existing entities
+    const labelList vertexHull = edgePoints_[eIndex];
+    label m = vertexHull.size();
+
+    // Size up the hull lists
+    labelList cellHull(m, -1);
+    labelList faceHull(m, -1);
+    labelList edgeHull(m, -1);
+    labelListList ringEntities(4, labelList(m, -1));
+
+    // Construct a hull around this edge
+    meshOps::constructHull
+    (
+        eIndex,
+        faces_,
+        edges_,
+        cells_,
+        owner_,
+        neighbour_,
+        faceEdges_,
+        edgeFaces_,
+        edgePoints_,
+        edgeHull,
+        faceHull,
+        cellHull,
+        ringEntities
+    );
+
+    if (debug > 1)
+    {
+        Info << nl << nl
+             << "Edge: " << eIndex
+             << ": " << edges_[eIndex]
+             << " is to be bisected. " << endl;
+
+        label epIndex = whichEdgePatch(eIndex);
+
+        Info << "Patch: ";
+
+        if (epIndex == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[epIndex].name() << endl;
+        }
+
+        // Write out VTK files prior to change
+        if (debug > 3)
+        {
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + "_Bisect_0",
+                cellHull
+            );
+        }
+    }
+
+    labelList mP(2, -1);
+
+    // Set mapping for this point
+    mP[0] = edges_[eIndex][0];
+    mP[1] = edges_[eIndex][1];
+
+    // Add a new point to the end of the list
+    label newPointIndex =
+    (
+        insertPoint
+        (
+            0.5 * (points_[mP[0]] + points_[mP[1]]),
+            0.5 * (oldPoints_[mP[0]] + oldPoints_[mP[1]]),
+            mP
+        )
+    );
+
+    // Add this point to the map.
+    map.addPoint(newPointIndex);
+
+    // New edges can lie on a bounding curve between
+    // coupled and non-coupled faces. Preferentially
+    // add edges to coupled-patches, if they exist.
+    // This makes it convenient for coupled patch matching.
+    label nePatch = -1;
+
+    {
+        nePatch = whichEdgePatch(eIndex);
+    }
+
+    // Add a new edge to the end of the list
+    label newEdgeIndex =
+    (
+        insertEdge
+        (
+            nePatch,
+            edge(newPointIndex,edges_[eIndex][1]),
+            labelList(faceHull.size(),-1),
+            vertexHull
+        )
+    );
+
+    // Add this edge to the map.
+    map.addEdge(newEdgeIndex);
+
+    // Remove the existing edge from the pointEdges list
+    // of the modified point, and add it to the new point
+    meshOps::sizeDownList(eIndex, pointEdges_[edges_[eIndex][1]]);
+    meshOps::sizeUpList(eIndex, pointEdges_[newPointIndex]);
+
+    // Modify the existing edge
+    edges_[eIndex][1] = newPointIndex;
+
+    // Add this edge to the map.
+    // Although this edge isn't technically 'added', it's
+    // required for coupled patch mapping.
+    map.addEdge(eIndex);
+
+    // Keep track of added entities
+    labelList addedCellIndices(cellHull.size(),-1);
+    labelList addedFaceIndices(faceHull.size(),-1);
+    labelList addedEdgeIndices(faceHull.size(),-1);
+    labelList addedIntFaceIndices(faceHull.size(),-1);
+
+    // Now loop through the hull and bisect individual entities
+    forAll(vertexHull, indexI)
+    {
+        // Modify the existing face
+        meshOps::replaceLabel
+        (
+            edges_[newEdgeIndex][1],
+            newPointIndex,
+            faces_[faceHull[indexI]]
+        );
+
+        // Modify edgePoints for the edge
+        meshOps::replaceLabel
+        (
+            edges_[newEdgeIndex][1],
+            newPointIndex,
+            edgePoints_[ringEntities[0][indexI]]
+        );
+
+        // Obtain circular indices
+        label nextI = vertexHull.fcIndex(indexI);
+        label prevI = vertexHull.rcIndex(indexI);
+
+        // Check if this is an interior/boundary face
+        if (cellHull[indexI] != -1)
+        {
+            // Create a new cell. Add it for now, but update later.
+            cell newCell(4);
+
+            addedCellIndices[indexI] =
+            (
+                insertCell(newCell, lengthScale_[cellHull[indexI]])
+            );
+
+            // Add this cell to the map.
+            map.addCell(addedCellIndices[indexI]);
+
+            // Configure the interior face
+            tmpTriFace[0] = vertexHull[nextI];
+            tmpTriFace[1] = vertexHull[indexI];
+            tmpTriFace[2] = newPointIndex;
+
+            // Insert the face
+            addedIntFaceIndices[indexI] =
+            (
+                insertFace
+                (
+                    -1,
+                    tmpTriFace,
+                    cellHull[indexI],
+                    addedCellIndices[indexI]
+                )
+            );
+
+            // Add a faceEdges entry as well
+            faceEdges_.append(tmpFaceEdges);
+
+            // Add this face to the map.
+            map.addFace(addedIntFaceIndices[indexI]);
+
+            // Add to the new cell
+            newCell[0] = addedIntFaceIndices[indexI];
+
+            // Modify the existing ring face connected to newEdge[1]
+            label replaceFace = ringEntities[3][indexI];
+
+            // Check if face reversal is necessary
+            if (owner_[replaceFace] == cellHull[indexI])
+            {
+                if (neighbour_[replaceFace] == -1)
+                {
+                    // Change the owner
+                    owner_[replaceFace] = addedCellIndices[indexI];
+                }
+                else
+                {
+                    // This face has to be reversed
+                    faces_[replaceFace] = faces_[replaceFace].reverseFace();
+                    owner_[replaceFace] = neighbour_[replaceFace];
+                    neighbour_[replaceFace] = addedCellIndices[indexI];
+
+                    setFlip(replaceFace);
+                }
+            }
+            else
+            {
+                // Keep owner, but change neighbour
+                neighbour_[replaceFace] = addedCellIndices[indexI];
+            }
+
+            // Modify the edge on the ring.
+            // Add the new interior face to edgeFaces.
+            meshOps::sizeUpList
+            (
+                addedIntFaceIndices[indexI],
+                edgeFaces_[edgeHull[indexI]]
+            );
+
+            // Insert the new point to edgePoints for the ring edge
+            meshOps::insertLabel
+            (
+                newPointIndex,
+                edges_[eIndex][0],
+                edges_[newEdgeIndex][1],
+                edgePoints_[edgeHull[indexI]]
+            );
+
+            // Add this edge to faceEdges for the new interior face
+            faceEdges_[addedIntFaceIndices[indexI]][0] = edgeHull[indexI];
+
+            // Replace face labels
+            meshOps::replaceLabel
+            (
+                replaceFace,
+                addedIntFaceIndices[indexI],
+                cells_[cellHull[indexI]]
+            );
+
+            // Add to the new cell
+            newCell[1] = replaceFace;
+
+            // Check if this is a boundary face
+            if (cellHull[prevI] == -1)
+            {
+                // Configure the boundary face
+                tmpTriFace[0] = newPointIndex;
+                tmpTriFace[1] = edges_[newEdgeIndex][1];
+                tmpTriFace[2] = vertexHull[indexI];
+
+                // Insert the face
+                addedFaceIndices[indexI] =
+                (
+                    insertFace
+                    (
+                        whichPatch(faceHull[indexI]),
+                        tmpTriFace,
+                        addedCellIndices[indexI],
+                        -1
+                    )
+                );
+
+                // Add this face to the map.
+                map.addFace(addedFaceIndices[indexI]);
+
+                // Configure edgeFaces
+                tmpEdgeFaces[0] = faceHull[indexI];
+                tmpEdgeFaces[1] = addedIntFaceIndices[indexI];
+                tmpEdgeFaces[2] = addedFaceIndices[indexI];
+
+                // Configure edgePoints
+                tmpEdgePoints[0] = edges_[eIndex][0];
+                tmpEdgePoints[1] = vertexHull[nextI];
+                tmpEdgePoints[2] = edges_[newEdgeIndex][1];
+
+                // Add an edge
+                addedEdgeIndices[indexI] =
+                (
+                    insertEdge
+                    (
+                        whichPatch(faceHull[indexI]),
+                        edge(newPointIndex,vertexHull[indexI]),
+                        tmpEdgeFaces,
+                        tmpEdgePoints
+                    )
+                );
+
+                // Add this edge to the map.
+                map.addEdge(addedEdgeIndices[indexI]);
+
+                // Add this edge to the interior-face faceEdges entry
+                faceEdges_[addedIntFaceIndices[indexI]][1] =
+                (
+                    addedEdgeIndices[indexI]
+                );
+
+                // Configure faceEdges for this boundary face
+                tmpFaceEdges[0] = addedEdgeIndices[indexI];
+                tmpFaceEdges[1] = newEdgeIndex;
+                tmpFaceEdges[2] = ringEntities[2][indexI];
+
+                // Modify faceEdges for the hull face
+                meshOps::replaceLabel
+                (
+                    ringEntities[2][indexI],
+                    addedEdgeIndices[indexI],
+                    faceEdges_[faceHull[indexI]]
+                );
+
+                // Modify edgeFaces for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    faceHull[indexI],
+                    addedFaceIndices[indexI],
+                    edgeFaces_[ringEntities[2][indexI]]
+                );
+
+                // Modify edgePoints for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    edges_[eIndex][0],
+                    newPointIndex,
+                    edgePoints_[ringEntities[2][indexI]]
+                );
+
+                // Add the faceEdges entry
+                faceEdges_.append(tmpFaceEdges);
+
+                // Add an entry to edgeFaces
+                edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
+
+                // Add an entry for this cell
+                newCell[2] = addedFaceIndices[indexI];
+            }
+            else
+            // Check if a cell was added before this
+            if (addedCellIndices[prevI] != -1)
+            {
+                // Configure the interior face
+                tmpTriFace[0] = vertexHull[indexI];
+                tmpTriFace[1] = edges_[newEdgeIndex][1];
+                tmpTriFace[2] = newPointIndex;
+
+                // Insert the face
+                addedFaceIndices[indexI] =
+                (
+                    insertFace
+                    (
+                        -1,
+                        tmpTriFace,
+                        addedCellIndices[prevI],
+                        addedCellIndices[indexI]
+                    )
+                );
+
+                // Add this face to the map.
+                map.addFace(addedFaceIndices[indexI]);
+
+                // Configure edgeFaces
+                tmpIntEdgeFaces[0] = faceHull[indexI];
+                tmpIntEdgeFaces[1] = addedIntFaceIndices[indexI];
+                tmpIntEdgeFaces[2] = addedFaceIndices[indexI];
+                tmpIntEdgeFaces[3] = addedIntFaceIndices[prevI];
+
+                // Configure edgePoints
+                tmpIntEdgePoints[0] = edges_[eIndex][0];
+                tmpIntEdgePoints[1] = vertexHull[nextI];
+                tmpIntEdgePoints[2] = edges_[newEdgeIndex][1];
+                tmpIntEdgePoints[3] = vertexHull[prevI];
+
+                // Add an internal edge
+                addedEdgeIndices[indexI] =
+                (
+                    insertEdge
+                    (
+                        -1,
+                        edge(newPointIndex,vertexHull[indexI]),
+                        tmpIntEdgeFaces,
+                        tmpIntEdgePoints
+                    )
+                );
+
+                // Add this edge to the map.
+                map.addEdge(addedEdgeIndices[indexI]);
+
+                // Add this edge to the interior-face faceEdges entry..
+                faceEdges_[addedIntFaceIndices[indexI]][1] =
+                (
+                    addedEdgeIndices[indexI]
+                );
+
+                // ... and to the previous interior face as well
+                faceEdges_[addedIntFaceIndices[prevI]][2] =
+                (
+                    addedEdgeIndices[indexI]
+                );
+
+                // Configure faceEdges for this split interior face
+                tmpFaceEdges[0] = addedEdgeIndices[indexI];
+                tmpFaceEdges[1] = newEdgeIndex;
+                tmpFaceEdges[2] = ringEntities[2][indexI];
+
+                // Modify faceEdges for the hull face
+                meshOps::replaceLabel
+                (
+                    ringEntities[2][indexI],
+                    addedEdgeIndices[indexI],
+                    faceEdges_[faceHull[indexI]]
+                );
+
+                // Modify edgeFaces for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    faceHull[indexI],
+                    addedFaceIndices[indexI],
+                    edgeFaces_[ringEntities[2][indexI]]
+                );
+
+                // Modify edgePoints for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    edges_[eIndex][0],
+                    newPointIndex,
+                    edgePoints_[ringEntities[2][indexI]]
+                );
+
+                // Add the faceEdges entry
+                faceEdges_.append(tmpFaceEdges);
+
+                // Add an entry to edgeFaces
+                edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
+
+                // Add an entry for this cell
+                newCell[2] = addedFaceIndices[indexI];
+
+                // Make the final entry for the previous cell
+                cells_[addedCellIndices[prevI]][3] = addedFaceIndices[indexI];
+            }
+
+            // Do the first interior face at the end
+            if (indexI == vertexHull.size() - 1)
+            {
+                // Configure the interior face
+                tmpTriFace[0] = newPointIndex;
+                tmpTriFace[1] = edges_[newEdgeIndex][1];
+                tmpTriFace[2] = vertexHull[0];
+
+                // Insert the face
+                addedFaceIndices[0] =
+                (
+                    insertFace
+                    (
+                        -1,
+                        tmpTriFace,
+                        addedCellIndices[0],
+                        addedCellIndices[indexI]
+                    )
+                );
+
+                // Add this face to the map.
+                map.addFace(addedFaceIndices[0]);
+
+                // Configure edgeFaces
+                tmpIntEdgeFaces[0] = faceHull[0];
+                tmpIntEdgeFaces[1] = addedIntFaceIndices[0];
+                tmpIntEdgeFaces[2] = addedFaceIndices[0];
+                tmpIntEdgeFaces[3] = addedIntFaceIndices[indexI];
+
+                // Configure edgePoints
+                tmpIntEdgePoints[0] = edges_[eIndex][0];
+                tmpIntEdgePoints[1] = vertexHull[1];
+                tmpIntEdgePoints[2] = edges_[newEdgeIndex][1];
+                tmpIntEdgePoints[3] = vertexHull[indexI];
+
+                // Add an internal edge
+                addedEdgeIndices[0] =
+                (
+                    insertEdge
+                    (
+                        -1,
+                        edge(newPointIndex,vertexHull[0]),
+                        tmpIntEdgeFaces,
+                        tmpIntEdgePoints
+                    )
+                );
+
+                // Add this edge to the map.
+                map.addEdge(addedEdgeIndices[0]);
+
+                // Add this edge to the interior-face faceEdges entry..
+                faceEdges_[addedIntFaceIndices[0]][1] =
+                (
+                    addedEdgeIndices[0]
+                );
+
+                // ... and to the previous interior face as well
+                faceEdges_[addedIntFaceIndices[indexI]][2] =
+                (
+                    addedEdgeIndices[0]
+                );
+
+                // Configure faceEdges for the first split face
+                tmpFaceEdges[0] = addedEdgeIndices[0];
+                tmpFaceEdges[1] = newEdgeIndex;
+                tmpFaceEdges[2] = ringEntities[2][0];
+
+                // Modify faceEdges for the hull face
+                meshOps::replaceLabel
+                (
+                    ringEntities[2][0],
+                    addedEdgeIndices[0],
+                    faceEdges_[faceHull[0]]
+                );
+
+                // Modify edgeFaces for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    faceHull[0],
+                    addedFaceIndices[0],
+                    edgeFaces_[ringEntities[2][0]]
+                );
+
+                // Modify edgePoints for the edge connected to newEdge[1]
+                meshOps::replaceLabel
+                (
+                    edges_[eIndex][0],
+                    newPointIndex,
+                    edgePoints_[ringEntities[2][0]]
+                );
+
+                // Add the faceEdges entry
+                faceEdges_.append(tmpFaceEdges);
+
+                // Add an entry to edgeFaces
+                edgeFaces_[newEdgeIndex][0] = addedFaceIndices[0];
+
+                // Add an entry for this cell
+                newCell[3] = addedFaceIndices[0];
+
+                // Make the final entry for the first cell
+                cells_[addedCellIndices[0]][2] = addedFaceIndices[0];
+            }
+
+            // Update the cell list with the new cell.
+            cells_[addedCellIndices[indexI]] = newCell;
+        }
+        else
+        {
+            // Configure the final boundary face
+            tmpTriFace[0] = vertexHull[indexI];
+            tmpTriFace[1] = edges_[newEdgeIndex][1];
+            tmpTriFace[2] = newPointIndex;
+
+            // Insert the face
+            addedFaceIndices[indexI] =
+            (
+                insertFace
+                (
+                    whichPatch(faceHull[indexI]),
+                    tmpTriFace,
+                    addedCellIndices[prevI],
+                    -1
+                )
+            );
+
+            // Add this face to the map.
+            map.addFace(addedFaceIndices[indexI]);
+
+            // Configure edgeFaces
+            tmpEdgeFaces[0] = addedFaceIndices[indexI];
+            tmpEdgeFaces[1] = addedIntFaceIndices[prevI];
+            tmpEdgeFaces[2] = faceHull[indexI];
+
+            // Configure edgePoints
+            tmpEdgePoints[0] = edges_[newEdgeIndex][1];
+            tmpEdgePoints[1] = vertexHull[prevI];
+            tmpEdgePoints[2] = edges_[eIndex][0];
+
+            // Add an edge
+            addedEdgeIndices[indexI] =
+            (
+                insertEdge
+                (
+                    whichPatch(faceHull[indexI]),
+                    edge(newPointIndex,vertexHull[indexI]),
+                    tmpEdgeFaces,
+                    tmpEdgePoints
+                )
+            );
+
+            // Add this edge to the map.
+            map.addEdge(addedEdgeIndices[indexI]);
+
+            // Add a faceEdges entry to the previous interior face
+            faceEdges_[addedIntFaceIndices[prevI]][2] =
+            (
+                addedEdgeIndices[indexI]
+            );
+
+            // Configure faceEdges for the final boundary face
+            tmpFaceEdges[0] = addedEdgeIndices[indexI];
+            tmpFaceEdges[1] = newEdgeIndex;
+            tmpFaceEdges[2] = ringEntities[2][indexI];
+
+            // Modify faceEdges for the hull face
+            meshOps::replaceLabel
+            (
+                ringEntities[2][indexI],
+                addedEdgeIndices[indexI],
+                faceEdges_[faceHull[indexI]]
+            );
+
+            // Modify edgeFaces for the edge connected to newEdge[1]
+            meshOps::replaceLabel
+            (
+                faceHull[indexI],
+                addedFaceIndices[indexI],
+                edgeFaces_[ringEntities[2][indexI]]
+            );
+
+            // Modify edgePoints for the edge connected to newEdge[1]
+            meshOps::replaceLabel
+            (
+                edges_[eIndex][0],
+                newPointIndex,
+                edgePoints_[ringEntities[2][indexI]]
+            );
+
+            // Add the faceEdges entry
+            faceEdges_.append(tmpFaceEdges);
+
+            // Add an entry to edgeFaces
+            edgeFaces_[newEdgeIndex][indexI] = addedFaceIndices[indexI];
+
+            // Make the final entry for the previous cell
+            cells_[addedCellIndices[prevI]][3] = addedFaceIndices[indexI];
+        }
+    }
+
+    // Now that all old / new cells possess correct connectivity,
+    // compute mapping information.
+    forAll(cellHull, indexI)
+    {
+        if (cellHull[indexI] == -1)
+        {
+            continue;
+        }
+
+        // Set mapping for both new and modified cells.
+        FixedList<label, 2> cmIndex;
+
+        cmIndex[0] = cellHull[indexI];
+        cmIndex[1] = addedCellIndices[indexI];
+
+        // Fill-in candidate mapping information
+        labelList mC(1, cellHull[indexI]);
+
+        forAll(cmIndex, cmI)
+        {
+            // Set the mapping for this cell
+            setCellMapping(cmIndex[cmI], mC);
+        }
+    }
+
+    // Set mapping information for old / new faces
+    forAll(faceHull, indexI)
+    {
+        // Interior faces get default mapping
+        if (addedIntFaceIndices[indexI] > -1)
+        {
+            setFaceMapping(addedIntFaceIndices[indexI]);
+        }
+
+        // Decide between default / weighted mapping
+        // based on boundary information
+        if (whichPatch(faceHull[indexI]) == -1)
+        {
+            // Interior faces get default mapping
+            setFaceMapping(faceHull[indexI]);
+            setFaceMapping(addedFaceIndices[indexI]);
+        }
+        else
+        {
+            // Compute mapping weights for boundary faces
+            FixedList<label, 2> fmIndex;
+
+            fmIndex[0] = faceHull[indexI];
+            fmIndex[1] = addedFaceIndices[indexI];
+
+            // Fill-in candidate mapping information
+            labelList mF(1, faceHull[indexI]);
+
+            forAll(fmIndex, fmI)
+            {
+                // Set the mapping for this face
+                setFaceMapping(fmIndex[fmI], mF);
+            }
+        }
+    }
+
+    if (debug > 2)
+    {
+        label bPatch = whichEdgePatch(eIndex);
+
+        if (bPatch == -1)
+        {
+            Info << "Patch: Internal" << endl;
+        }
+        else
+        {
+            Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+        }
+
+        Info << "EdgePoints: " << vertexHull << endl;
+        Info << "Edges: " << edgeHull << endl;
+        Info << "Faces: " << faceHull << endl;
+        Info << "Cells: " << cellHull << endl;
+
+        Info << "Modified cells: " << endl;
+
+        forAll(cellHull, cellI)
+        {
+            if (cellHull[cellI] == -1)
+            {
+                continue;
+            }
+
+            Info << cellHull[cellI] << ":: "
+                 << cells_[cellHull[cellI]]
+                 << endl;
+        }
+
+        Info << "Added cells: " << endl;
+
+        forAll(addedCellIndices, cellI)
+        {
+            if (addedCellIndices[cellI] == -1)
+            {
+                continue;
+            }
+
+            Info << addedCellIndices[cellI] << ":: "
+                 << cells_[addedCellIndices[cellI]] << nl
+                 << "lengthScale: " << lengthScale_[addedCellIndices[cellI]]
+                 << endl;
+        }
+
+        Info << "Modified faces: " << endl;
+
+        forAll(faceHull, faceI)
+        {
+            Info << faceHull[faceI] << ":: "
+                 << faces_[faceHull[faceI]] << ": "
+                 << owner_[faceHull[faceI]] << ": "
+                 << neighbour_[faceHull[faceI]] << " "
+                 << "faceEdges:: " << faceEdges_[faceHull[faceI]]
+                 << endl;
+        }
+
+        Info << "Added faces: " << endl;
+
+        forAll(addedFaceIndices, faceI)
+        {
+            Info << addedFaceIndices[faceI] << ":: "
+                 << faces_[addedFaceIndices[faceI]] << ": "
+                 << owner_[addedFaceIndices[faceI]] << ": "
+                 << neighbour_[addedFaceIndices[faceI]] << " "
+                 << "faceEdges:: " << faceEdges_[addedFaceIndices[faceI]]
+                 << endl;
+        }
+
+        forAll(addedIntFaceIndices, faceI)
+        {
+            if (addedIntFaceIndices[faceI] == -1)
+            {
+                continue;
+            }
+
+            Info << addedIntFaceIndices[faceI] << ":: "
+                 << faces_[addedIntFaceIndices[faceI]] << ": "
+                 << owner_[addedIntFaceIndices[faceI]] << ": "
+                 << neighbour_[addedIntFaceIndices[faceI]] << " "
+                 << "faceEdges:: "
+                 << faceEdges_[addedIntFaceIndices[faceI]]
+                 << endl;
+        }
+
+        Info << "New edge:: " << newEdgeIndex
+             << ": " << edges_[newEdgeIndex] << nl
+             << " edgeFaces:: " << edgeFaces_[newEdgeIndex] << nl
+             << " edgePoints:: " << edgePoints_[newEdgeIndex]
+             << endl;
+
+        Info << "Added edges: " << endl;
+
+        forAll(addedEdgeIndices, edgeI)
+        {
+            Info << addedEdgeIndices[edgeI]
+                 << ":: " << edges_[addedEdgeIndices[edgeI]] << nl
+                 << " edgeFaces:: " << edgeFaces_[addedEdgeIndices[edgeI]] << nl
+                 << " edgePoints:: " << edgePoints_[addedEdgeIndices[edgeI]]
+                 << endl;
+        }
+
+        Info << "New Point:: " << newPointIndex << endl;
+        Info << "pointEdges:: " << pointEdges_[newPointIndex] << endl;
+
+        // Write out VTK files after change
+        if (debug > 3)
+        {
+            labelList newHull(cellHull.size() + addedCellIndices.size(), 0);
+
+            // Combine both lists into one.
+            forAll(cellHull, i)
+            {
+                newHull[i] = cellHull[i];
+            }
+
+            label start = cellHull.size();
+
+            for(label i = start; i < newHull.size(); i++)
+            {
+                newHull[i] = addedCellIndices[i - start];
+            }
+
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + "_Bisect_1",
+                newHull
+            );
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Increment the counter
+    statistics_[3]++;
+
+    // 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, edgeFaces and edgePoints information.
+
+    // Figure out which thread this is...
+    label tIndex = self();
+
+    // Prepare the changeMaps
+    changeMap map, slaveMap;
+
+    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);
+    }
+
+    // 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), newTriEdgePoints(3);
+    labelList newQuadEdgeFaces(4), newQuadEdgePoints(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)
+    {
+        Info << 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 an entry for edgePoints as well
+    newTriEdgePoints[0] = faces_[fIndex][0];
+    newTriEdgePoints[1] = faces_[fIndex][1];
+    newTriEdgePoints[2] = faces_[fIndex][2];
+
+    // Add a new internal edge to the mesh
+    newEdgeIndex[0] =
+    (
+        insertEdge
+        (
+            -1,
+            edge
+            (
+               newPointIndex,
+               apexPoint[0]
+            ),
+            newTriEdgeFaces,
+            newTriEdgePoints
+        )
+    );
+
+    // 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 and edgePoints for three new boundary edges.
+        newTriEdgeFaces[0] = newFaceIndex[4];
+        newTriEdgeFaces[1] = newFaceIndex[0];
+        newTriEdgeFaces[2] = newFaceIndex[3];
+
+        newTriEdgePoints[0] = faces_[fIndex][1];
+        newTriEdgePoints[1] = apexPoint[0];
+        newTriEdgePoints[2] = faces_[fIndex][2];
+
+        newEdgeIndex[1] =
+        (
+            insertEdge
+            (
+                facePatch,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][0]
+                ),
+                newTriEdgeFaces,
+                newTriEdgePoints
+            )
+        );
+
+        newTriEdgeFaces[0] = newFaceIndex[5];
+        newTriEdgeFaces[1] = newFaceIndex[1];
+        newTriEdgeFaces[2] = newFaceIndex[4];
+
+        newTriEdgePoints[0] = faces_[fIndex][2];
+        newTriEdgePoints[1] = apexPoint[0];
+        newTriEdgePoints[2] = faces_[fIndex][0];
+
+        newEdgeIndex[2] =
+        (
+            insertEdge
+            (
+                facePatch,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][1]
+                ),
+                newTriEdgeFaces,
+                newTriEdgePoints
+            )
+        );
+
+        newTriEdgeFaces[0] = newFaceIndex[3];
+        newTriEdgeFaces[1] = newFaceIndex[2];
+        newTriEdgeFaces[2] = newFaceIndex[5];
+
+        newTriEdgePoints[0] = faces_[fIndex][0];
+        newTriEdgePoints[1] = apexPoint[0];
+        newTriEdgePoints[2] = faces_[fIndex][1];
+
+        newEdgeIndex[3] =
+        (
+            insertEdge
+            (
+                facePatch,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][2]
+                ),
+                newTriEdgeFaces,
+                newTriEdgePoints
+            )
+        );
+
+        // 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
+        labelHashSet cellEdges;
+
+        forAll(cells_[owner_[fIndex]], faceI)
+        {
+            const labelList& fEdges =
+            (
+                faceEdges_[cells_[owner_[fIndex]][faceI]]
+            );
+
+            forAll(fEdges, edgeI)
+            {
+                if (!cellEdges.found(fEdges[edgeI]))
+                {
+                    cellEdges.insert(fEdges[edgeI]);
+                }
+            }
+        }
+
+        // Loop through cellEdges, and perform appropriate actions.
+        forAllIter(labelHashSet, cellEdges, eIter)
+        {
+            const edge& edgeToCheck = edges_[eIter.key()];
+
+            // Check against the specified edges.
+            if (edgeToCheck == check[0])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][1],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[eIter.key()]);
+                newFaceEdges[0][nE[0]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[1])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[eIter.key()]);
+                newFaceEdges[1][nE[1]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[2])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][1],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[eIter.key()]);
+                newFaceEdges[2][nE[2]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[3])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][1],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[3],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[3][nE[3]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[4])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][2],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[4],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[4][nE[4]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[5])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][0],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[5],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[5][nE[5]++] = eIter.key();
+            }
+        }
+
+        // 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]);
+        }
+    }
+    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 and edgePoints for four new interior edges.
+        newQuadEdgeFaces[0] = newFaceIndex[4];
+        newQuadEdgeFaces[1] = newFaceIndex[0];
+        newQuadEdgeFaces[2] = newFaceIndex[3];
+        newQuadEdgeFaces[3] = newFaceIndex[6];
+
+        newQuadEdgePoints[0] = faces_[fIndex][1];
+        newQuadEdgePoints[1] = apexPoint[0];
+        newQuadEdgePoints[2] = faces_[fIndex][2];
+        newQuadEdgePoints[3] = apexPoint[1];
+
+        newEdgeIndex[1] =
+        (
+            insertEdge
+            (
+                -1,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][0]
+                ),
+                newQuadEdgeFaces,
+                newQuadEdgePoints
+            )
+        );
+
+        newQuadEdgeFaces[0] = newFaceIndex[5];
+        newQuadEdgeFaces[1] = newFaceIndex[1];
+        newQuadEdgeFaces[2] = newFaceIndex[4];
+        newQuadEdgeFaces[3] = newFaceIndex[7];
+
+        newQuadEdgePoints[0] = faces_[fIndex][2];
+        newQuadEdgePoints[1] = apexPoint[0];
+        newQuadEdgePoints[2] = faces_[fIndex][0];
+        newQuadEdgePoints[3] = apexPoint[1];
+
+        newEdgeIndex[2] =
+        (
+            insertEdge
+            (
+                -1,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][1]
+                ),
+                newQuadEdgeFaces,
+                newQuadEdgePoints
+            )
+        );
+
+        newQuadEdgeFaces[0] = newFaceIndex[3];
+        newQuadEdgeFaces[1] = newFaceIndex[2];
+        newQuadEdgeFaces[2] = newFaceIndex[5];
+        newQuadEdgeFaces[3] = newFaceIndex[8];
+
+        newQuadEdgePoints[0] = faces_[fIndex][0];
+        newQuadEdgePoints[1] = apexPoint[0];
+        newQuadEdgePoints[2] = faces_[fIndex][1];
+        newQuadEdgePoints[3] = apexPoint[1];
+
+        newEdgeIndex[3] =
+        (
+            insertEdge
+            (
+                -1,
+                edge
+                (
+                   newPointIndex,
+                   faces_[fIndex][2]
+                ),
+                newQuadEdgeFaces,
+                newQuadEdgePoints
+            )
+        );
+
+        newTriEdgeFaces[0] = newFaceIndex[6];
+        newTriEdgeFaces[1] = newFaceIndex[7];
+        newTriEdgeFaces[2] = newFaceIndex[8];
+
+        newTriEdgePoints[0] = faces_[fIndex][0];
+        newTriEdgePoints[1] = faces_[fIndex][1];
+        newTriEdgePoints[2] = faces_[fIndex][2];
+
+        newEdgeIndex[4] =
+        (
+            insertEdge
+            (
+                -1,
+                edge
+                (
+                   apexPoint[1],
+                   newPointIndex
+                ),
+                newTriEdgeFaces,
+                newTriEdgePoints
+            )
+        );
+
+        // 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
+        labelHashSet cellEdges;
+
+        forAll(cells_[owner_[fIndex]], faceI)
+        {
+            const labelList& fEdges =
+            (
+                faceEdges_[cells_[owner_[fIndex]][faceI]]
+            );
+
+            forAll(fEdges, edgeI)
+            {
+                if (!cellEdges.found(fEdges[edgeI]))
+                {
+                    cellEdges.insert(fEdges[edgeI]);
+                }
+            }
+        }
+
+        forAll(cells_[neighbour_[fIndex]], faceI)
+        {
+            const labelList& fEdges =
+            (
+                faceEdges_[cells_[neighbour_[fIndex]][faceI]]
+            );
+
+            forAll(fEdges, edgeI)
+            {
+                if (!cellEdges.found(fEdges[edgeI]))
+                {
+                    cellEdges.insert(fEdges[edgeI]);
+                }
+            }
+        }
+
+        // Loop through cellEdges, and perform appropriate actions.
+        forAllIter(labelHashSet, cellEdges, eIter)
+        {
+            const edge& edgeToCheck = edges_[eIter.key()];
+
+            // Check against the specified edges.
+            if (edgeToCheck == check[0])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][1],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[0], edgeFaces_[eIter.key()]);
+                newFaceEdges[0][nE[0]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[1])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[1], edgeFaces_[eIter.key()]);
+                newFaceEdges[1][nE[1]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[2])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][1],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[2], edgeFaces_[eIter.key()]);
+                newFaceEdges[2][nE[2]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[3])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][1],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[3],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[3][nE[3]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[4])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][2],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[4],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[4][nE[4]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[5])
+            {
+                meshOps::replaceLabel
+                (
+                    faces_[fIndex][0],
+                    newPointIndex,
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fIndex,
+                    newFaceIndex[5],
+                    edgeFaces_[eIter.key()]
+                );
+
+                newFaceEdges[5][nE[5]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[6])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][1],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[6], edgeFaces_[eIter.key()]);
+                newFaceEdges[6][nE[6]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[7])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][2],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[7], edgeFaces_[eIter.key()]);
+                newFaceEdges[7][nE[7]++] = eIter.key();
+            }
+
+            if (edgeToCheck == check[8])
+            {
+                meshOps::insertLabel
+                (
+                    newPointIndex,
+                    faces_[fIndex][0],
+                    faces_[fIndex][1],
+                    edgePoints_[eIter.key()]
+                );
+
+                meshOps::sizeUpList(newFaceIndex[8], edgeFaces_[eIter.key()]);
+                newFaceEdges[8][nE[8]++] = eIter.key();
+            }
+        }
+
+        // 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)
+    {
+        Info << "New Point:: " << newPointIndex << endl;
+
+        const labelList& pEdges = pointEdges_[newPointIndex];
+
+        Info << "pointEdges:: " << pEdges << endl;
+
+        Info << "Added edges: " << endl;
+        forAll(pEdges, edgeI)
+        {
+            Info << pEdges[edgeI]
+                 << ":: " << edges_[pEdges[edgeI]] << nl
+                 << " edgeFaces:: " << edgeFaces_[pEdges[edgeI]] << nl
+                 << " edgePoints:: " << edgePoints_[pEdges[edgeI]]
+                 << endl;
+        }
+
+        Info << "Added faces: " << endl;
+        forAll(newFaceIndex, faceI)
+        {
+            if (newFaceIndex[faceI] == -1)
+            {
+                continue;
+            }
+
+            Info << newFaceIndex[faceI] << ":: "
+                 << faces_[newFaceIndex[faceI]]
+                 << endl;
+        }
+
+        Info << "Added cells: " << endl;
+        forAll(newCellIndex, cellI)
+        {
+            if (newCellIndex[cellI] == -1)
+            {
+                continue;
+            }
+
+            Info << 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]++;
+
+    // Specify that the operation was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+
+// Utility method to compute the quality of a
+// vertex hull around an edge after bisection.
+scalar dynamicTopoFvMesh::computeBisectionQuality
+(
+    const label eIndex
+) const
+{
+    scalar minQuality = GREAT, minVolume = GREAT;
+    scalar cQuality = 0.0, oldVolume = 0.0;
+
+    // Obtain a reference to this edge and corresponding edgePoints
+    const edge& edgeToCheck = edges_[eIndex];
+    const labelList& hullVertices = edgePoints_[eIndex];
+
+    // Obtain point references
+    const point& a = points_[edgeToCheck[0]];
+    const point& c = points_[edgeToCheck[1]];
+
+    const point& aOld = oldPoints_[edgeToCheck[0]];
+    const point& cOld = oldPoints_[edgeToCheck[1]];
+
+    // Compute the mid-point of the edge
+    point midPoint = 0.5*(a + c);
+    point oldPoint = 0.5*(aOld + cOld);
+
+    if (whichEdgePatch(eIndex) < 0)
+    {
+        // Internal edge.
+        forAll(hullVertices, indexI)
+        {
+            label prevIndex = hullVertices.rcIndex(indexI);
+
+            // Pick vertices off the list
+            const point& b = points_[hullVertices[prevIndex]];
+            const point& d = points_[hullVertices[indexI]];
+
+            const point& bOld = oldPoints_[hullVertices[prevIndex]];
+            const point& dOld = oldPoints_[hullVertices[indexI]];
+
+            // Compute the quality of the upper half.
+            cQuality = tetMetric_(a, b, midPoint, d);
+
+            // Compute old volume of the upper half.
+            oldVolume = tetPointRef(aOld, bOld, oldPoint, dOld).mag();
+
+            // Check if the volume / quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+            minVolume = Foam::min(oldVolume, minVolume);
+
+            // Compute the quality of the lower half.
+            cQuality = tetMetric_(midPoint, b, c, d);
+
+            // Compute old volume of the lower half.
+            oldVolume = tetPointRef(oldPoint, bOld, cOld, dOld).mag();
+
+            // Check if the quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+            minVolume = Foam::min(oldVolume, minVolume);
+        }
+    }
+    else
+    {
+        // Boundary edge.
+        for(label indexI = 1; indexI < hullVertices.size(); indexI++)
+        {
+            // Pick vertices off the list
+            const point& b = points_[hullVertices[indexI-1]];
+            const point& d = points_[hullVertices[indexI]];
+
+            const point& bOld = oldPoints_[hullVertices[indexI-1]];
+            const point& dOld = oldPoints_[hullVertices[indexI]];
+
+            // Compute the quality of the upper half.
+            cQuality = tetMetric_(a, b, midPoint, d);
+
+            // Compute old volume of the upper half.
+            oldVolume = tetPointRef(aOld, bOld, oldPoint, dOld).mag();
+
+            // Check if the quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+            minVolume = Foam::min(oldVolume, minVolume);
+
+            // Compute the quality of the lower half.
+            cQuality = tetMetric_(midPoint, b, c, d);
+
+            // Compute old volume of the lower half.
+            oldVolume = tetPointRef(oldPoint, bOld, cOld, dOld).mag();
+
+            // Check if the quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+            minVolume = Foam::min(oldVolume, minVolume);
+        }
+    }
+
+    // Ensure that the mesh is valid
+    if (minQuality < sliverThreshold_)
+    {
+        if (debug > 3 && minQuality < 0.0)
+        {
+            // Write out cells for post processing.
+            labelHashSet iCells;
+
+            const labelList& eFaces = edgeFaces_[eIndex];
+
+            forAll(eFaces, faceI)
+            {
+                if (!iCells.found(owner_[eFaces[faceI]]))
+                {
+                    iCells.insert(owner_[eFaces[faceI]]);
+                }
+
+                if (!iCells.found(neighbour_[eFaces[faceI]]))
+                {
+                    iCells.insert(neighbour_[eFaces[faceI]]);
+                }
+            }
+
+            writeVTK(Foam::name(eIndex) + "_iCells", iCells.toc());
+        }
+
+        if (debug > 2)
+        {
+            InfoIn
+            (
+                "scalar dynamicTopoFvMesh::computeBisectionQuality"
+                "(const label eIndex) const"
+            )
+                << "Bisecting edge will fall below the "
+                << "sliver threshold of: " << sliverThreshold_ << nl
+                << "Edge: " << eIndex << ": " << edgeToCheck << nl
+                << "EdgePoints: " << hullVertices << nl
+                << "Minimum Quality: " << minQuality << nl
+                << "Mid point: " << midPoint
+                << endl;
+        }
+    }
+
+    // If a negative old-volume was encountered,
+    // return an invalid quality.
+    if (minVolume < 0.0)
+    {
+        return minVolume;
+    }
+
+    return minQuality;
+}
+
+
+// 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
+    meshOps::faceCentre(faces_[fIndex], points_, midPoint);
+
+    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;
+}
+
+
+// Split a set of internal faces into boundary faces
+//   - Add boundary faces and edges to the patch specified by 'patchIndex'
+//   - Cell color should specify a binary value dictating either side
+//     of the split face.
+void dynamicTopoFvMesh::splitInternalFaces
+(
+    const label patchIndex,
+    const labelList& internalFaces,
+    const Map<bool>& cellColors
+)
+{
+    Map<label> mirrorPointLabels;
+    FixedList<Map<label>, 2> mirrorEdgeLabels, mirrorFaceLabels;
+
+    // First loop through the list and accumulate a list of
+    // points and edges that need to be duplicated.
+    forAll(internalFaces, faceI)
+    {
+        const face& faceToCheck = faces_[internalFaces[faceI]];
+
+        forAll(faceToCheck, pointI)
+        {
+            if (!mirrorPointLabels.found(faceToCheck[pointI]))
+            {
+                mirrorPointLabels.insert(faceToCheck[pointI], -1);
+            }
+        }
+
+        const labelList& fEdges = faceEdges_[internalFaces[faceI]];
+
+        forAll(fEdges, edgeI)
+        {
+            if (!mirrorEdgeLabels[0].found(fEdges[edgeI]))
+            {
+                mirrorEdgeLabels[0].insert(fEdges[edgeI], -1);
+            }
+        }
+    }
+
+    // Now for every point in the list, add a new one.
+    // Add a mapping entry as well.
+    forAllIter(Map<label>, mirrorPointLabels, pIter)
+    {
+        // Obtain a copy of the point before adding it,
+        // since the reference might become invalid during list resizing.
+        point newPoint = points_[pIter.key()];
+        point oldPoint = oldPoints_[pIter.key()];
+
+        pIter() = insertPoint(newPoint, oldPoint, labelList(1, pIter.key()));
+
+        if (!twoDMesh_)
+        {
+            const labelList& pEdges = pointEdges_[pIter.key()];
+
+            labelHashSet edgesToRemove;
+
+            forAll(pEdges, edgeI)
+            {
+                const labelList& eFaces = edgeFaces_[pEdges[edgeI]];
+
+                bool allTrue = true;
+
+                forAll(eFaces, faceI)
+                {
+                    label own = owner_[eFaces[faceI]];
+                    label nei = neighbour_[eFaces[faceI]];
+
+                    // Check if an owner/neighbour cell is false
+                    if (!cellColors[own])
+                    {
+                        allTrue = false;
+                        break;
+                    }
+
+                    if (nei != -1)
+                    {
+                        if (!cellColors[nei])
+                        {
+                            allTrue = false;
+                            break;
+                        }
+                    }
+                }
+
+                if (allTrue)
+                {
+                    // Mark this edge label to be discarded later
+                    edgesToRemove.insert(pEdges[edgeI]);
+                }
+            }
+
+            // It is dangerous to use the pointEdges references,
+            // so call it using array-lookup instead.
+            forAllIter(labelHashSet, edgesToRemove, hsIter)
+            {
+                // Add the edge to the mirror point list
+                meshOps::sizeUpList
+                (
+                    hsIter.key(),
+                    pointEdges_[pIter()]
+                );
+
+                // Remove the edge from the original point list
+                meshOps::sizeDownList
+                (
+                    hsIter.key(),
+                    pointEdges_[pIter.key()]
+                );
+            }
+        }
+    }
+
+    if (debug > 3)
+    {
+        label i = 0;
+        labelList mPoints(mirrorPointLabels.size());
+
+        if (!twoDMesh_)
+        {
+            forAllIter(Map<label>, mirrorPointLabels, pIter)
+            {
+                writeVTK
+                (
+                    "pEdges_o_" + Foam::name(pIter.key()) + '_',
+                    pointEdges_[pIter.key()],
+                    1
+                );
+
+                writeVTK
+                (
+                    "pEdges_m_" + Foam::name(pIter()) + '_',
+                    pointEdges_[pIter()],
+                    1
+                );
+
+                mPoints[i++] = pIter();
+            }
+
+            writeVTK
+            (
+                "points_o_",
+                mirrorPointLabels.toc(),
+                0
+            );
+
+            writeVTK
+            (
+                "points_m_",
+                mPoints,
+                0
+            );
+        }
+    }
+
+    // For every internal face, add a new one.
+    //  - Stick to the rule:
+    //    [1] Every cell marked false keeps the existing entities.
+    //    [2] Every cell marked true gets new points/edges/faces.
+    //  - If faces are improperly oriented, reverse them.
+    forAll(internalFaces, faceI)
+    {
+        FixedList<face, 2> newFace;
+        FixedList<label, 2> newFaceIndex(-1);
+        FixedList<label, 2> newOwner(-1);
+
+        label oldOwn = owner_[internalFaces[faceI]];
+        label oldNei = neighbour_[internalFaces[faceI]];
+
+        if (cellColors[oldOwn] && !cellColors[oldNei])
+        {
+            // The owner gets a new boundary face.
+            // Note that orientation is already correct.
+            newFace[0] = faces_[internalFaces[faceI]];
+
+            // The neighbour needs to have its face reversed
+            // and moved to the boundary patch, thereby getting
+            // deleted in the process.
+            newFace[1] = newFace[0].reverseFace();
+
+            newOwner[0] = oldOwn;
+            newOwner[1] = oldNei;
+        }
+        else
+        if (!cellColors[oldOwn] && cellColors[oldNei])
+        {
+            // The neighbour gets a new boundary face.
+            // The face is oriented in the opposite sense, however.
+            newFace[0] = faces_[internalFaces[faceI]].reverseFace();
+
+            // The owner keeps the existing face and orientation.
+            // But it also needs to be moved to the boundary.
+            newFace[1] = faces_[internalFaces[faceI]];
+
+            newOwner[0] = oldNei;
+            newOwner[1] = oldOwn;
+        }
+        else
+        {
+            // Something's wrong here.
+            FatalErrorIn
+            (
+                "dynamicTopoFvMesh::splitInternalFaces\n"
+                "(\n"
+                "    const label patchIndex,\n"
+                "    const labelList& internalFaces,\n"
+                "    const Map<bool>& cellColors\n"
+                ")\n"
+            )
+                << nl << " Face: "
+                << internalFaces[faceI]
+                << " has cells which are improperly marked: " << nl
+                << oldOwn << ":: " << cellColors[oldOwn] << nl
+                << oldNei << ":: " << cellColors[oldNei]
+                << abort(FatalError);
+        }
+
+        // Renumber point labels for the first new face.
+        forAll(newFace[0], pointI)
+        {
+            newFace[0][pointI] = mirrorPointLabels[newFace[0][pointI]];
+        }
+
+        // Insert the new boundary faces.
+        forAll(newFace, indexI)
+        {
+            newFaceIndex[indexI] =
+            (
+                insertFace
+                (
+                    patchIndex,
+                    newFace[indexI],
+                    newOwner[indexI],
+                    -1
+                )
+            );
+
+            // 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
+            (
+                internalFaces[faceI],
+                newFaceIndex[indexI],
+                cells_[newOwner[indexI]]
+            );
+
+            // Make face mapping entries for posterity.
+            mirrorFaceLabels[indexI].insert
+            (
+                internalFaces[faceI],
+                newFaceIndex[indexI]
+            );
+        }
+    }
+
+    // For every edge in the list, add a new one.
+    // We'll deal with correcting edgeFaces and edgePoints later.
+    forAllIter(Map<label>, mirrorEdgeLabels[0], eIter)
+    {
+        // Obtain copies for the append method
+        edge origEdge = edges_[eIter.key()];
+        labelList newEdgeFaces(edgeFaces_[eIter.key()]);
+
+        eIter() =
+        (
+            insertEdge
+            (
+                patchIndex,
+                edge
+                (
+                    mirrorPointLabels[origEdge[0]],
+                    mirrorPointLabels[origEdge[1]]
+                ),
+                newEdgeFaces,
+                labelList(0)
+            )
+        );
+
+        // Is the original edge an internal one?
+        // If it is, we need to move it to the boundary.
+        if (whichEdgePatch(eIter.key()) == -1)
+        {
+            label rplEdgeIndex =
+            (
+                insertEdge
+                (
+                    patchIndex,
+                    origEdge,
+                    newEdgeFaces,
+                    labelList(0)
+                )
+            );
+
+            // Map the new entry.
+            mirrorEdgeLabels[1].insert(eIter.key(), rplEdgeIndex);
+        }
+        else
+        {
+            // This is already a boundary edge.
+            // Make an identical map.
+            mirrorEdgeLabels[1].insert(eIter.key(), eIter.key());
+        }
+    }
+
+    // Correct edgeFaces for all new edges
+    forAll(mirrorEdgeLabels, indexI)
+    {
+        forAllIter(Map<label>, mirrorEdgeLabels[indexI], eIter)
+        {
+            labelList& eFaces = edgeFaces_[eIter()];
+
+            labelHashSet facesToRemove;
+
+            forAll(eFaces, faceI)
+            {
+                bool remove = false;
+
+                label own = owner_[eFaces[faceI]];
+                label nei = neighbour_[eFaces[faceI]];
+
+                if
+                (
+                    (!cellColors[own] && !indexI) ||
+                    ( cellColors[own] &&  indexI)
+                )
+                {
+                    remove = true;
+                }
+
+                if (nei != -1)
+                {
+                    if
+                    (
+                        (!cellColors[nei] && !indexI) ||
+                        ( cellColors[nei] &&  indexI)
+                    )
+                    {
+                        remove = true;
+                    }
+                }
+
+                if (mirrorFaceLabels[indexI].found(eFaces[faceI]))
+                {
+                    // Perform a replacement instead of a removal.
+                    eFaces[faceI] = mirrorFaceLabels[indexI][eFaces[faceI]];
+
+                    remove = false;
+                }
+
+                if (remove)
+                {
+                    facesToRemove.insert(eFaces[faceI]);
+                }
+            }
+
+            // Now successively size down edgeFaces.
+            // It is dangerous to use the eFaces reference,
+            // so call it using array-lookup.
+            forAllIter(labelHashSet, facesToRemove, hsIter)
+            {
+                meshOps::sizeDownList(hsIter.key(), edgeFaces_[eIter()]);
+            }
+        }
+    }
+
+    // Renumber faceEdges for all faces connected to new edges
+    forAll(mirrorEdgeLabels, indexI)
+    {
+        forAllIter(Map<label>, mirrorEdgeLabels[indexI], eIter)
+        {
+            const labelList& eFaces = edgeFaces_[eIter()];
+
+            forAll(eFaces, faceI)
+            {
+                labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    if (mirrorEdgeLabels[indexI].found(fEdges[edgeI]))
+                    {
+                        fEdges[edgeI] =
+                        (
+                            mirrorEdgeLabels[indexI][fEdges[edgeI]]
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    if (twoDMesh_)
+    {
+        // Renumber edges and faces
+        forAllIter(Map<label>, mirrorEdgeLabels[0], eIter)
+        {
+            const labelList& eFaces = edgeFaces_[eIter()];
+
+            // Two levels of indirection to ensure
+            // that all entities we renumbered.
+            // A flip-side for the lack of a pointEdges list in 2D.
+            forAll(eFaces, faceI)
+            {
+                const labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    // Renumber this edge.
+                    edge& edgeToCheck = edges_[fEdges[edgeI]];
+
+                    forAll(edgeToCheck, pointI)
+                    {
+                        if (mirrorPointLabels.found(edgeToCheck[pointI]))
+                        {
+                            edgeToCheck[pointI] =
+                            (
+                                mirrorPointLabels[edgeToCheck[pointI]]
+                            );
+                        }
+                    }
+
+                    // Also renumber faces connected to this edge.
+                    const labelList& efFaces = edgeFaces_[fEdges[edgeI]];
+
+                    forAll(efFaces, faceJ)
+                    {
+                        face& faceToCheck = faces_[efFaces[faceJ]];
+
+                        forAll(faceToCheck, pointI)
+                        {
+                            if
+                            (
+                                mirrorPointLabels.found(faceToCheck[pointI])
+                            )
+                            {
+                                faceToCheck[pointI] =
+                                (
+                                    mirrorPointLabels[faceToCheck[pointI]]
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        // Point renumbering of entities connected to mirror points
+        forAllIter(Map<label>, mirrorPointLabels, pIter)
+        {
+            const labelList& pEdges = pointEdges_[pIter()];
+
+            forAll(pEdges, edgeI)
+            {
+                // Renumber this edge.
+                edge& edgeToCheck = edges_[pEdges[edgeI]];
+
+                forAll(edgeToCheck, pointI)
+                {
+                    if (edgeToCheck[pointI] == pIter.key())
+                    {
+                        edgeToCheck[pointI] = pIter();
+                    }
+                }
+
+                // Also renumber faces connected to this edge.
+                const labelList& eFaces = edgeFaces_[pEdges[edgeI]];
+
+                forAll(eFaces, faceI)
+                {
+                    face& faceToCheck = faces_[eFaces[faceI]];
+
+                    forAll(faceToCheck, pointI)
+                    {
+                        if (faceToCheck[pointI] == pIter.key())
+                        {
+                            faceToCheck[pointI] = pIter();
+                        }
+                    }
+                }
+            }
+        }
+
+        // Scan edges connected to mirror points,
+        // and correct any edgePoints entries for
+        // edges connected to the other vertex.
+        forAllIter(Map<label>, mirrorPointLabels, pIter)
+        {
+            const labelList& pEdges = pointEdges_[pIter()];
+
+            forAll(pEdges, edgeI)
+            {
+                label otherVertex = edges_[pEdges[edgeI]].otherVertex(pIter());
+
+                // Scan edgePoints for edges connected to this point
+                const labelList& opEdges = pointEdges_[otherVertex];
+
+                forAll(opEdges, edgeJ)
+                {
+                    labelList& ePoints = edgePoints_[opEdges[edgeJ]];
+
+                    forAll(ePoints, pointI)
+                    {
+                        if (mirrorPointLabels.found(ePoints[pointI]))
+                        {
+                            // Replace this point with the mirror point
+                            ePoints[pointI] =
+                            (
+                                mirrorPointLabels[ePoints[pointI]]
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        // Build edgePoints for new edges
+        forAll(mirrorEdgeLabels, indexI)
+        {
+            forAllIter(Map<label>, mirrorEdgeLabels[indexI], eIter)
+            {
+                buildEdgePoints(eIter());
+            }
+        }
+    }
+
+    // Now that we're done with the internal faces, remove them.
+    forAll(internalFaces, faceI)
+    {
+        removeFace(internalFaces[faceI]);
+    }
+
+    // Remove old internal edges as well.
+    forAllIter(Map<label>, mirrorEdgeLabels[1], eIter)
+    {
+        if (eIter.key() != eIter())
+        {
+            removeEdge(eIter.key());
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
new file mode 100644
index 000000000..191f32821
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeCollapse.C
@@ -0,0 +1,3718 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "Stack.H"
+#include "objectMap.H"
+#include "changeMap.H"
+#include "multiThreader.H"
+#include "dynamicTopoFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Method for the collapse of a quad-face in 2D
+// - Returns a changeMap with a type specifying:
+//    -1: Collapse failed since max number of topo-changes was reached.
+//     0: Collapse could not be performed.
+//     1: Collapsed to first node.
+//     2: Collapsed to second node.
+// - overRideCase is used to force a certain collapse configuration.
+//    -1: Use this value to let collapseQuadFace decide a case.
+//     1: Force collapse to first node.
+//     2: Force collapse to second node.
+// - checkOnly performs a feasibility check and returns without modifications.
+const changeMap dynamicTopoFvMesh::collapseQuadFace
+(
+    const label fIndex,
+    label overRideCase,
+    bool checkOnly,
+    bool forceOp
+)
+{
+    // Figure out which thread this is...
+    label tIndex = self();
+
+    // Prepare the changeMap
+    changeMap map;
+
+    if
+    (
+        (statistics_[0] > maxModifications_)
+     && (maxModifications_ > -1)
+    )
+    {
+        // Reached the max allowable topo-changes.
+        stack(tIndex).clear();
+
+        return map;
+    }
+
+    // Check if edgeRefinements are to be avoided on patch.
+    if (lengthEstimator().checkRefinementPatch(whichPatch(fIndex)))
+    {
+        return map;
+    }
+
+    // Sanity check: Is the index legitimate?
+    if (fIndex < 0)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap "
+            "dynamicTopoFvMesh::collapseQuadFace\n"
+            "(\n"
+            "    const label fIndex,\n"
+            "    label overRideCase,\n"
+            "    bool checkOnly\n"
+            ")\n"
+        )
+            << " Invalid index: " << fIndex
+            << abort(FatalError);
+    }
+
+    // Define the edges on the face to be collapsed
+    FixedList<edge,4> checkEdge(edge(-1,-1));
+    FixedList<label,4> checkEdgeIndex(-1);
+
+    // Define checkEdges
+    checkEdgeIndex[0] = getTriBoundaryEdge(fIndex);
+    checkEdge[0] = edges_[checkEdgeIndex[0]];
+
+    const labelList& fEdges = faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        if (checkEdgeIndex[0] != fEdges[edgeI])
+        {
+            const edge& thisEdge = edges_[fEdges[edgeI]];
+
+            if
+            (
+                checkEdge[0].start() == thisEdge[0] ||
+                checkEdge[0].start() == thisEdge[1]
+            )
+            {
+                checkEdgeIndex[1] = fEdges[edgeI];
+                checkEdge[1] = thisEdge;
+
+                // Update the map
+                map.firstEdge() = checkEdgeIndex[1];
+            }
+            else
+            if
+            (
+                checkEdge[0].end() == thisEdge[0] ||
+                checkEdge[0].end() == thisEdge[1]
+            )
+            {
+                checkEdgeIndex[2] = fEdges[edgeI];
+                checkEdge[2] = thisEdge;
+
+                // Update the map
+                map.secondEdge() = checkEdgeIndex[2];
+            }
+            else
+            {
+                checkEdgeIndex[3] = fEdges[edgeI];
+                checkEdge[3] = thisEdge;
+            }
+        }
+    }
+
+    // Build a hull of cells and tri-faces that are connected to each edge
+    FixedList<labelList, 2> hullCells;
+    FixedList<labelList, 2> hullTriFaces;
+
+    meshOps::constructPrismHull
+    (
+        checkEdgeIndex[1],
+        faces_,
+        cells_,
+        owner_,
+        neighbour_,
+        edgeFaces_,
+        hullTriFaces[0],
+        hullCells[0]
+    );
+
+    meshOps::constructPrismHull
+    (
+        checkEdgeIndex[2],
+        faces_,
+        cells_,
+        owner_,
+        neighbour_,
+        edgeFaces_,
+        hullTriFaces[1],
+        hullCells[1]
+    );
+
+    // Determine the neighbouring cells
+    label c0 = owner_[fIndex], c1 = neighbour_[fIndex];
+
+    // Define variables for the prism-face calculation
+    FixedList<face,2> c0BdyFace, c0IntFace, c1BdyFace, c1IntFace;
+    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
+
+    // Find the prism-faces
+    meshOps::findPrismFaces
+    (
+        fIndex,
+        c0,
+        faces_,
+        cells_,
+        neighbour_,
+        c0BdyFace,
+        c0BdyIndex,
+        c0IntFace,
+        c0IntIndex
+    );
+
+    if (c1 != -1)
+    {
+        meshOps::findPrismFaces
+        (
+            fIndex,
+            c1,
+            faces_,
+            cells_,
+            neighbour_,
+            c1BdyFace,
+            c1BdyIndex,
+            c1IntFace,
+            c1IntIndex
+        );
+    }
+
+    // Determine if either edge belongs to a boundary
+    FixedList<bool, 2> nBoundCurves(false), edgeBoundary(false);
+
+    edgeBoundary[0] = (whichEdgePatch(checkEdgeIndex[1]) > -1);
+    edgeBoundary[1] = (whichEdgePatch(checkEdgeIndex[2]) > -1);
+
+    // Decide on collapseCase
+    label collapseCase = -1;
+
+    if (edgeBoundary[0] && !edgeBoundary[1])
+    {
+        collapseCase = 1;
+    }
+    else
+    if (!edgeBoundary[0] && edgeBoundary[1])
+    {
+        collapseCase = 2;
+    }
+    else
+    if (edgeBoundary[0] && edgeBoundary[1])
+    {
+        if (c1 != -1)
+        {
+            if (debug > 2)
+            {
+                WarningIn
+                (
+                    "\n"
+                    "const changeMap "
+                    "dynamicTopoFvMesh::collapseQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly\n"
+                    ")\n"
+                )   << "Collapsing an internal face that "
+                    << "lies on two boundary patches. "
+                    << "Face: " << fIndex << ": " << faces_[fIndex]
+                    << endl;
+            }
+
+            // Bail out for now. If proximity based refinement is
+            // switched on, mesh may be sliced at this point.
+            return map;
+        }
+
+        // Check if either edge lies on a bounding curve.
+        if (checkBoundingCurve(checkEdgeIndex[1]))
+        {
+            nBoundCurves[0] = true;
+        }
+
+        if (checkBoundingCurve(checkEdgeIndex[2]))
+        {
+            nBoundCurves[1] = true;
+        }
+
+        // Collapse towards a bounding curve
+        if (nBoundCurves[0] && !nBoundCurves[1])
+        {
+            collapseCase = 1;
+        }
+        else
+        if (!nBoundCurves[0] && nBoundCurves[1])
+        {
+            collapseCase = 2;
+        }
+        else
+        if (!nBoundCurves[0] && !nBoundCurves[1])
+        {
+            // No bounding curves. Collapse to mid-point.
+            collapseCase = 3;
+        }
+        else
+        {
+            // Two bounding curves? This might cause pinching.
+            // Bail out for now.
+            return map;
+        }
+    }
+    else
+    {
+        // Looks like this is an interior face.
+        // Collapse case [3] by default
+        collapseCase = 3;
+    }
+
+    // Perform an override if requested.
+    if (overRideCase != -1)
+    {
+        collapseCase = overRideCase;
+    }
+
+    // Configure the new point-positions
+    FixedList<bool, 2> check(false);
+    FixedList<FixedList<label, 2>, 2> checkPoints(-1);
+    FixedList<point, 2> newPoint(vector::zero);
+    FixedList<point, 2> oldPoint(vector::zero);
+
+    // Determine the common vertices for the first and second edges
+    label cv0 = checkEdge[1].commonVertex(checkEdge[0]);
+    label cv1 = checkEdge[1].commonVertex(checkEdge[3]);
+    label cv2 = checkEdge[2].commonVertex(checkEdge[0]);
+    label cv3 = checkEdge[2].commonVertex(checkEdge[3]);
+
+    // Replacement check points
+    FixedList<label,2> original(-1), replacement(-1);
+
+    switch (collapseCase)
+    {
+        case 1:
+        {
+            // Collapse to the first node
+            original[0] = cv2; original[1] = cv3;
+            replacement[0] = cv0; replacement[1] = cv1;
+
+            newPoint[0] = points_[replacement[0]];
+            newPoint[1] = points_[replacement[1]];
+
+            oldPoint[0] = oldPoints_[replacement[0]];
+            oldPoint[1] = oldPoints_[replacement[1]];
+
+            // Define check-points
+            check[1] = true;
+            checkPoints[1][0] = original[0];
+            checkPoints[1][1] = original[1];
+
+            break;
+        }
+
+        case 2:
+        {
+            // Collapse to the second node
+            original[0] = cv0; original[1] = cv1;
+            replacement[0] = cv2; replacement[1] = cv3;
+
+            newPoint[0] = points_[replacement[0]];
+            newPoint[1] = points_[replacement[1]];
+
+            oldPoint[0] = oldPoints_[replacement[0]];
+            oldPoint[1] = oldPoints_[replacement[1]];
+
+            // Define check-points
+            check[0] = true;
+            checkPoints[0][0] = original[0];
+            checkPoints[0][1] = original[1];
+
+            break;
+        }
+
+        case 3:
+        {
+            // Collapse to the mid-point
+            original[0] = cv0; original[1] = cv1;
+            replacement[0] = cv2; replacement[1] = cv3;
+
+            // Define new point-positions
+            newPoint[0] =
+            (
+                0.5 *
+                (
+                    points_[original[0]]
+                  + points_[replacement[0]]
+                )
+            );
+
+            newPoint[1] =
+            (
+                0.5 *
+                (
+                    points_[original[1]]
+                  + points_[replacement[1]]
+                )
+            );
+
+            // Specify off-centering
+            scalar offCentre = (c1 == -1) ? 0.0 : 1.0;
+
+            FixedList<vector,2> te(vector::zero), xf(vector::zero);
+            FixedList<vector,2> ne(vector::zero), nf(vector::zero);
+
+            // Compute tangent-to-edge
+            te[0] = (oldPoints_[replacement[0]] - oldPoints_[original[0]]);
+            te[1] = (oldPoints_[replacement[1]] - oldPoints_[original[1]]);
+
+            // Compute face position / normal
+            if (c0BdyFace[0].which(original[0]) > -1)
+            {
+                meshOps::faceCentre(c0BdyFace[0], oldPoints_, xf[0]);
+                meshOps::faceNormal(c0BdyFace[0], oldPoints_, nf[0]);
+
+                meshOps::faceCentre(c0BdyFace[1], oldPoints_, xf[1]);
+                meshOps::faceNormal(c0BdyFace[1], oldPoints_, nf[1]);
+            }
+            else
+            if (c0BdyFace[1].which(original[0]) > -1)
+            {
+                meshOps::faceCentre(c0BdyFace[1], oldPoints_, xf[0]);
+                meshOps::faceNormal(c0BdyFace[1], oldPoints_, nf[0]);
+
+                meshOps::faceCentre(c0BdyFace[0], oldPoints_, xf[1]);
+                meshOps::faceNormal(c0BdyFace[0], oldPoints_, nf[1]);
+            }
+            else
+            {
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap "
+                    "dynamicTopoFvMesh::collapseQuadFace\n"
+                    "(\n"
+                    "    const label fIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly\n"
+                    ")\n"
+                )   << "Could not find point in face."
+                    << endl;
+            }
+
+            // Compute edge-normals
+            ne[0] = (te[0] ^ nf[0]);
+            ne[1] = (te[1] ^ nf[1]);
+
+            ne[0] /= mag(ne[0]) + VSMALL;
+            ne[1] /= mag(ne[1]) + VSMALL;
+
+            // Reverse the vector, if necessary
+            if ((ne[0] & ne[1]) < 0.0)
+            {
+                ne[1] *= -1.0;
+            }
+
+            // Define modified old point-positions,
+            // with off-centering, if necessary
+            oldPoint[0] =
+            (
+                oldPoints_[original[0]]
+              + (0.5 * te[0])
+              + (((0.05 * mag(te[0])) * ne[0]) * offCentre)
+            );
+
+            oldPoint[1] =
+            (
+                oldPoints_[original[1]]
+              + (0.5 * te[1])
+              + (((0.05 * mag(te[1])) * ne[1]) * offCentre)
+            );
+
+            // Define check-points
+            check[0] = true;
+            checkPoints[0][0] = original[0];
+            checkPoints[0][1] = original[1];
+
+            check[1] = true;
+            checkPoints[1][0] = replacement[0];
+            checkPoints[1][1] = replacement[1];
+
+            break;
+        }
+
+        default:
+        {
+            // Don't think this will ever happen.
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap "
+                "dynamicTopoFvMesh::collapseQuadFace\n"
+                "(\n"
+                "    const label fIndex,\n"
+                "    label overRideCase,\n"
+                "    bool checkOnly\n"
+                ")\n"
+            )
+                << "Edge: " << fIndex << ": " << faces_[fIndex]
+                << ". Couldn't decide on collapseCase."
+                << abort(FatalError);
+
+            break;
+        }
+    }
+
+    // Keep track of resulting cell quality,
+    // if collapse is indeed feasible
+    scalar collapseQuality(GREAT);
+
+    // Check collapsibility of cells around edges
+    // with the re-configured point
+    forAll(check, indexI)
+    {
+        if (!check[indexI])
+        {
+            continue;
+        }
+
+        // Check whether the collapse is possible.
+        if
+        (
+            checkCollapse
+            (
+                hullTriFaces[indexI],
+                c0BdyIndex,
+                c1BdyIndex,
+                checkPoints[indexI],
+                newPoint,
+                oldPoint,
+                collapseQuality,
+                (c1 != -1),
+                forceOp
+            )
+        )
+        {
+            map.type() = 0;
+            return map;
+        }
+    }
+
+    // Are we only performing checks?
+    if (checkOnly)
+    {
+        map.type() = collapseCase;
+
+        if (debug > 2)
+        {
+            Info << "Face: " << fIndex
+                 << ":: " << faces_[fIndex] << nl
+                 << " collapseCase determined to be: "
+                 << collapseCase << nl
+                 << " Resulting quality: "
+                 << collapseQuality
+                 << endl;
+        }
+
+        return map;
+    }
+
+    if (debug > 1)
+    {
+        const labelList& fE = faceEdges_[fIndex];
+
+        Info << nl << nl
+             << "Face: " << fIndex << ": " << faces_[fIndex] << nl
+             << "faceEdges: " << fE
+             << " is to be collapsed. " << endl;
+
+        label epIndex = whichPatch(fIndex);
+
+        Info << "Patch: ";
+
+        if (epIndex == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[epIndex].name() << endl;
+        }
+
+        if (debug > 2)
+        {
+            Info << endl;
+            Info << "~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+            Info << "Hulls before modification" << endl;
+            Info << "~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+
+            Info << nl << "Cells belonging to first Edge Hull: "
+                 << hullCells[0] << endl;
+
+            forAll(hullCells[0],cellI)
+            {
+                const cell& firstCurCell = cells_[hullCells[0][cellI]];
+
+                Info << "Cell: " << hullCells[0][cellI]
+                     << ": " << firstCurCell << endl;
+
+                forAll(firstCurCell,faceI)
+                {
+                    Info << firstCurCell[faceI]
+                         << ": " << faces_[firstCurCell[faceI]] << endl;
+                }
+            }
+
+            const labelList& firstEdgeFaces = edgeFaces_[checkEdgeIndex[1]];
+
+            Info << nl << "First Edge Face Hull: "
+                 << firstEdgeFaces << endl;
+
+            forAll(firstEdgeFaces,indexI)
+            {
+                Info << firstEdgeFaces[indexI]
+                     << ": " << faces_[firstEdgeFaces[indexI]] << endl;
+            }
+
+            Info << nl << "Cells belonging to second Edge Hull: "
+                 << hullCells[1] << endl;
+
+            forAll(hullCells[1], cellI)
+            {
+                const cell& secondCurCell = cells_[hullCells[1][cellI]];
+
+                Info << "Cell: " << hullCells[1][cellI]
+                     << ": " << secondCurCell << endl;
+
+                forAll(secondCurCell, faceI)
+                {
+                    Info << secondCurCell[faceI]
+                         << ": " << faces_[secondCurCell[faceI]] << endl;
+                }
+            }
+
+            const labelList& secondEdgeFaces = edgeFaces_[checkEdgeIndex[2]];
+
+            Info << nl << "Second Edge Face Hull: "
+                 << secondEdgeFaces << endl;
+
+            forAll(secondEdgeFaces, indexI)
+            {
+                Info << secondEdgeFaces[indexI]
+                     << ": " << faces_[secondEdgeFaces[indexI]] << endl;
+            }
+
+            // Write out VTK files prior to change
+            if (debug > 3)
+            {
+                labelHashSet vtkCells;
+
+                forAll(hullCells[0], cellI)
+                {
+                    if (!vtkCells.found(hullCells[0][cellI]))
+                    {
+                        vtkCells.insert(hullCells[0][cellI]);
+                    }
+                }
+
+                forAll(hullCells[1], cellI)
+                {
+                    if (!vtkCells.found(hullCells[1][cellI]))
+                    {
+                        vtkCells.insert(hullCells[1][cellI]);
+                    }
+                }
+
+                writeVTK
+                (
+                    Foam::name(fIndex)
+                  + "_Collapse_0",
+                    vtkCells.toc()
+                );
+            }
+        }
+    }
+
+    // Edges / Quad-faces to throw or keep during collapse
+    FixedList<label,2> ends(-1);
+    FixedList<label,2> faceToKeep(-1), faceToThrow(-1);
+    FixedList<label,4> edgeToKeep(-1), edgeToThrow(-1);
+
+    // Maintain a list of modified faces for mapping
+    labelHashSet modifiedFaces;
+
+    // Case 2 & 3 use identical connectivity,
+    // but different point locations
+    if (collapseCase == 2 || collapseCase == 3)
+    {
+        const labelList& firstEdgeFaces = edgeFaces_[checkEdgeIndex[1]];
+
+        // Collapse to the second node...
+        forAll(firstEdgeFaces,faceI)
+        {
+            // Replace point indices on faces.
+            meshOps::replaceLabel
+            (
+                cv0,
+                cv2,
+                faces_[firstEdgeFaces[faceI]]
+            );
+
+            meshOps::replaceLabel
+            (
+                cv1,
+                cv3,
+                faces_[firstEdgeFaces[faceI]]
+            );
+
+            // Add an entry for mapping
+            if (!modifiedFaces.found(firstEdgeFaces[faceI]))
+            {
+                modifiedFaces.insert(firstEdgeFaces[faceI]);
+            }
+
+            // Determine the quad-face in cell[0] & cell[1]
+            // that belongs to firstEdgeFaces
+            if (firstEdgeFaces[faceI] == c0IntIndex[0])
+            {
+                faceToKeep[0]  = c0IntIndex[1];
+                faceToThrow[0] = c0IntIndex[0];
+            }
+
+            if (firstEdgeFaces[faceI] == c0IntIndex[1])
+            {
+                faceToKeep[0]  = c0IntIndex[0];
+                faceToThrow[0] = c0IntIndex[1];
+            }
+
+            if (c1 != -1)
+            {
+                if (firstEdgeFaces[faceI] == c1IntIndex[0])
+                {
+                    faceToKeep[1]  = c1IntIndex[1];
+                    faceToThrow[1] = c1IntIndex[0];
+                }
+
+                if (firstEdgeFaces[faceI] == c1IntIndex[1])
+                {
+                    faceToKeep[1]  = c1IntIndex[0];
+                    faceToThrow[1] = c1IntIndex[1];
+                }
+            }
+        }
+
+        // Find common edges between quad / tri faces...
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[0],
+            faceToKeep[0],
+            faceEdges_,
+            edgeToKeep[0]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[1],
+            faceToKeep[0],
+            faceEdges_,
+            edgeToKeep[1]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[0],
+            faceToThrow[0],
+            faceEdges_,
+            edgeToThrow[0]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[1],
+            faceToThrow[0],
+            faceEdges_,
+            edgeToThrow[1]
+        );
+
+        // Size down edgeFaces for the ends.
+        meshOps::findCommonEdge
+        (
+            faceToThrow[0],
+            faceToKeep[0],
+            faceEdges_,
+            ends[0]
+        );
+
+        meshOps::sizeDownList
+        (
+            faceToThrow[0],
+            edgeFaces_[ends[0]]
+        );
+
+        if (c1 != -1)
+        {
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                faceToKeep[1],
+                faceEdges_,
+                edgeToKeep[2]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                faceToKeep[1],
+                faceEdges_,
+                edgeToKeep[3]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                faceToThrow[1],
+                faceEdges_,
+                edgeToThrow[2]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                faceToThrow[1],
+                faceEdges_,
+                edgeToThrow[3]
+            );
+
+            // Size down edgeFaces for the ends.
+            meshOps::findCommonEdge
+            (
+                faceToThrow[1],
+                faceToKeep[1],
+                faceEdges_,
+                ends[1]
+            );
+
+            meshOps::sizeDownList
+            (
+                faceToThrow[1],
+                edgeFaces_[ends[1]]
+            );
+        }
+
+        // Correct edgeFaces for triangular faces...
+        forAll(edgeToThrow, indexI)
+        {
+            if (edgeToThrow[indexI] == -1)
+            {
+                continue;
+            }
+
+            const labelList& eF = edgeFaces_[edgeToThrow[indexI]];
+
+            label origTriFace = -1, retTriFace = -1;
+
+            // Find the original triangular face index
+            forAll(eF, faceI)
+            {
+                if (eF[faceI] == c0BdyIndex[0])
+                {
+                    origTriFace = c0BdyIndex[0];
+                    break;
+                }
+
+                if (eF[faceI] == c0BdyIndex[1])
+                {
+                    origTriFace = c0BdyIndex[1];
+                    break;
+                }
+
+                if (eF[faceI] == c1BdyIndex[0])
+                {
+                    origTriFace = c1BdyIndex[0];
+                    break;
+                }
+
+                if (eF[faceI] == c1BdyIndex[1])
+                {
+                    origTriFace = c1BdyIndex[1];
+                    break;
+                }
+            }
+
+            // Find the retained triangular face index
+            forAll(eF, faceI)
+            {
+                if
+                (
+                    (eF[faceI] != origTriFace) &&
+                    (eF[faceI] != faceToThrow[0]) &&
+                    (eF[faceI] != faceToThrow[1])
+                )
+                {
+                    retTriFace = eF[faceI];
+                    break;
+                }
+            }
+
+            // Finally replace the face index
+            if (retTriFace == -1)
+            {
+                // Couldn't find a retained face.
+                // This must be a boundary edge, so size-down instead.
+                meshOps::sizeDownList
+                (
+                    origTriFace,
+                    edgeFaces_[edgeToKeep[indexI]]
+                );
+            }
+            else
+            {
+                meshOps::replaceLabel
+                (
+                    origTriFace,
+                    retTriFace,
+                    edgeFaces_[edgeToKeep[indexI]]
+                );
+
+                meshOps::replaceLabel
+                (
+                    edgeToThrow[indexI],
+                    edgeToKeep[indexI],
+                    faceEdges_[retTriFace]
+                );
+            }
+        }
+
+        // Correct faceEdges / edgeFaces for quad-faces...
+        forAll(firstEdgeFaces,faceI)
+        {
+            meshOps::replaceLabel
+            (
+                checkEdgeIndex[1],
+                checkEdgeIndex[2],
+                faceEdges_[firstEdgeFaces[faceI]]
+            );
+
+            // Renumber the edges on this face
+            const labelList& fE = faceEdges_[firstEdgeFaces[faceI]];
+
+            forAll(fE, edgeI)
+            {
+                if (edges_[fE[edgeI]].start() == cv0)
+                {
+                    edges_[fE[edgeI]].start() = cv2;
+                }
+
+                if (edges_[fE[edgeI]].end() == cv0)
+                {
+                    edges_[fE[edgeI]].end() = cv2;
+                }
+
+                if (edges_[fE[edgeI]].start() == cv1)
+                {
+                    edges_[fE[edgeI]].start() = cv3;
+                }
+
+                if (edges_[fE[edgeI]].end() == cv1)
+                {
+                    edges_[fE[edgeI]].end() = cv3;
+                }
+            }
+
+            // Size-up edgeFaces for the replacement
+            if
+            (
+                (firstEdgeFaces[faceI] != faceToThrow[0]) &&
+                (firstEdgeFaces[faceI] != faceToThrow[1]) &&
+                (firstEdgeFaces[faceI] != fIndex)
+            )
+            {
+                meshOps::sizeUpList
+                (
+                    firstEdgeFaces[faceI],
+                    edgeFaces_[checkEdgeIndex[2]]
+                );
+            }
+        }
+
+        // Remove the current face from the replacement edge
+        meshOps::sizeDownList
+        (
+            fIndex,
+            edgeFaces_[checkEdgeIndex[2]]
+        );
+
+        // Replace point labels on all triangular boundary faces.
+        forAll(hullCells[0],cellI)
+        {
+            const cell& cellToCheck = cells_[hullCells[0][cellI]];
+
+            forAll(cellToCheck,faceI)
+            {
+                face& faceToCheck = faces_[cellToCheck[faceI]];
+
+                if (faceToCheck.size() == 3)
+                {
+                    forAll(faceToCheck,pointI)
+                    {
+                        if (faceToCheck[pointI] == cv0)
+                        {
+                            faceToCheck[pointI] = cv2;
+                        }
+
+                        if (faceToCheck[pointI] == cv1)
+                        {
+                            faceToCheck[pointI] = cv3;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Now that we're done with all edges, remove them.
+        removeEdge(checkEdgeIndex[0]);
+        removeEdge(checkEdgeIndex[1]);
+        removeEdge(checkEdgeIndex[3]);
+
+        forAll(edgeToThrow, indexI)
+        {
+            if (edgeToThrow[indexI] == -1)
+            {
+                continue;
+            }
+
+            removeEdge(edgeToThrow[indexI]);
+        }
+
+        // Delete the two points...
+        removePoint(cv0);
+        removePoint(cv1);
+    }
+    else
+    {
+        const labelList& secondEdgeFaces = edgeFaces_[checkEdgeIndex[2]];
+
+        // Collapse to the first node
+        forAll(secondEdgeFaces,faceI)
+        {
+            // Replace point indices on faces.
+            meshOps::replaceLabel
+            (
+                cv2,
+                cv0,
+                faces_[secondEdgeFaces[faceI]]
+            );
+
+            meshOps::replaceLabel
+            (
+                cv3,
+                cv1,
+                faces_[secondEdgeFaces[faceI]]
+            );
+
+            // Add an entry for mapping
+            if (!modifiedFaces.found(secondEdgeFaces[faceI]))
+            {
+                modifiedFaces.insert(secondEdgeFaces[faceI]);
+            }
+
+            // Determine the quad-face(s) in cell[0] & cell[1]
+            // that belongs to secondEdgeFaces
+            if (secondEdgeFaces[faceI] == c0IntIndex[0])
+            {
+                faceToKeep[0]  = c0IntIndex[1];
+                faceToThrow[0] = c0IntIndex[0];
+            }
+
+            if (secondEdgeFaces[faceI] == c0IntIndex[1])
+            {
+                faceToKeep[0]  = c0IntIndex[0];
+                faceToThrow[0] = c0IntIndex[1];
+            }
+
+            if (c1 != -1)
+            {
+                if (secondEdgeFaces[faceI] == c1IntIndex[0])
+                {
+                    faceToKeep[1]  = c1IntIndex[1];
+                    faceToThrow[1] = c1IntIndex[0];
+                }
+
+                if (secondEdgeFaces[faceI] == c1IntIndex[1])
+                {
+                    faceToKeep[1]  = c1IntIndex[0];
+                    faceToThrow[1] = c1IntIndex[1];
+                }
+            }
+        }
+
+        // Find common edges between quad / tri faces...
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[0],
+            faceToKeep[0],
+            faceEdges_,
+            edgeToKeep[0]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[1],
+            faceToKeep[0],
+            faceEdges_,
+            edgeToKeep[1]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[0],
+            faceToThrow[0],
+            faceEdges_,
+            edgeToThrow[0]
+        );
+
+        meshOps::findCommonEdge
+        (
+            c0BdyIndex[1],
+            faceToThrow[0],
+            faceEdges_,
+            edgeToThrow[1]
+        );
+
+        // Size down edgeFaces for the ends.
+        meshOps::findCommonEdge
+        (
+            faceToThrow[0],
+            faceToKeep[0],
+            faceEdges_,
+            ends[0]
+        );
+
+        meshOps::sizeDownList
+        (
+            faceToThrow[0],
+            edgeFaces_[ends[0]]
+        );
+
+        if (c1 != -1)
+        {
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                faceToKeep[1],
+                faceEdges_,
+                edgeToKeep[2]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                faceToKeep[1],
+                faceEdges_,
+                edgeToKeep[3]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[0],
+                faceToThrow[1],
+                faceEdges_,
+                edgeToThrow[2]
+            );
+
+            meshOps::findCommonEdge
+            (
+                c1BdyIndex[1],
+                faceToThrow[1],
+                faceEdges_,
+                edgeToThrow[3]
+            );
+
+            // Size down edgeFaces for the ends.
+            meshOps::findCommonEdge
+            (
+                faceToThrow[1],
+                faceToKeep[1],
+                faceEdges_,
+                ends[1]
+            );
+
+            meshOps::sizeDownList
+            (
+                faceToThrow[1],
+                edgeFaces_[ends[1]]
+            );
+        }
+
+        // Correct edgeFaces for triangular faces...
+        forAll(edgeToThrow, indexI)
+        {
+            if (edgeToThrow[indexI] == -1)
+            {
+                continue;
+            }
+
+            const labelList& eF = edgeFaces_[edgeToThrow[indexI]];
+
+            label origTriFace = -1, retTriFace = -1;
+
+            // Find the original triangular face index
+            forAll(eF, faceI)
+            {
+                if (eF[faceI] == c0BdyIndex[0])
+                {
+                    origTriFace = c0BdyIndex[0];
+                    break;
+                }
+
+                if (eF[faceI] == c0BdyIndex[1])
+                {
+                    origTriFace = c0BdyIndex[1];
+                    break;
+                }
+
+                if (eF[faceI] == c1BdyIndex[0])
+                {
+                    origTriFace = c1BdyIndex[0];
+                    break;
+                }
+
+                if (eF[faceI] == c1BdyIndex[1])
+                {
+                    origTriFace = c1BdyIndex[1];
+                    break;
+                }
+            }
+
+            // Find the retained triangular face index
+            forAll(eF, faceI)
+            {
+                if
+                (
+                    (eF[faceI] != origTriFace) &&
+                    (eF[faceI] != faceToThrow[0]) &&
+                    (eF[faceI] != faceToThrow[1])
+                )
+                {
+                    retTriFace = eF[faceI];
+                    break;
+                }
+            }
+
+            // Finally replace the face/edge indices
+            if (retTriFace == -1)
+            {
+                // Couldn't find a retained face.
+                // This must be a boundary edge, so size-down instead.
+                meshOps::sizeDownList
+                (
+                    origTriFace,
+                    edgeFaces_[edgeToKeep[indexI]]
+                );
+            }
+            else
+            {
+                meshOps::replaceLabel
+                (
+                    origTriFace,
+                    retTriFace,
+                    edgeFaces_[edgeToKeep[indexI]]
+                );
+
+                meshOps::replaceLabel
+                (
+                    edgeToThrow[indexI],
+                    edgeToKeep[indexI],
+                    faceEdges_[retTriFace]
+                );
+            }
+        }
+
+        // Correct faceEdges / edgeFaces for quad-faces...
+        forAll(secondEdgeFaces,faceI)
+        {
+            meshOps::replaceLabel
+            (
+                checkEdgeIndex[2],
+                checkEdgeIndex[1],
+                faceEdges_[secondEdgeFaces[faceI]]
+            );
+
+            // Renumber the edges on this face
+            const labelList& fE = faceEdges_[secondEdgeFaces[faceI]];
+
+            forAll(fE, edgeI)
+            {
+                if (edges_[fE[edgeI]].start() == cv2)
+                {
+                    edges_[fE[edgeI]].start() = cv0;
+                }
+
+                if (edges_[fE[edgeI]].end() == cv2)
+                {
+                    edges_[fE[edgeI]].end() = cv0;
+                }
+
+                if (edges_[fE[edgeI]].start() == cv3)
+                {
+                    edges_[fE[edgeI]].start() = cv1;
+                }
+
+                if (edges_[fE[edgeI]].end() == cv3)
+                {
+                    edges_[fE[edgeI]].end() = cv1;
+                }
+            }
+
+            // Size-up edgeFaces for the replacement
+            if
+            (
+                (secondEdgeFaces[faceI] != faceToThrow[0]) &&
+                (secondEdgeFaces[faceI] != faceToThrow[1]) &&
+                (secondEdgeFaces[faceI] != fIndex)
+            )
+            {
+                meshOps::sizeUpList
+                (
+                    secondEdgeFaces[faceI],
+                    edgeFaces_[checkEdgeIndex[1]]
+                );
+            }
+        }
+
+        // Remove the current face from the replacement edge
+        meshOps::sizeDownList
+        (
+            fIndex,
+            edgeFaces_[checkEdgeIndex[1]]
+        );
+
+        // Replace point labels on all triangular boundary faces.
+        forAll(hullCells[1], cellI)
+        {
+            const cell& cellToCheck = cells_[hullCells[1][cellI]];
+
+            forAll(cellToCheck, faceI)
+            {
+                face& faceToCheck = faces_[cellToCheck[faceI]];
+
+                if (faceToCheck.size() == 3)
+                {
+                    forAll(faceToCheck, pointI)
+                    {
+                        if (faceToCheck[pointI] == cv2)
+                        {
+                            faceToCheck[pointI] = cv0;
+                        }
+
+                        if (faceToCheck[pointI] == cv3)
+                        {
+                            faceToCheck[pointI] = cv1;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Now that we're done with all edges, remove them.
+        removeEdge(checkEdgeIndex[0]);
+        removeEdge(checkEdgeIndex[2]);
+        removeEdge(checkEdgeIndex[3]);
+
+        forAll(edgeToThrow, indexI)
+        {
+            if (edgeToThrow[indexI] == -1)
+            {
+                continue;
+            }
+
+            removeEdge(edgeToThrow[indexI]);
+        }
+
+        // Delete the two points...
+        removePoint(cv2);
+        removePoint(cv3);
+    }
+
+    if (debug > 2)
+    {
+        Info << endl;
+        Info << "~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+        Info << "Hulls after modification" << endl;
+        Info << "~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
+
+        Info << nl << "Cells belonging to first Edge Hull: "
+             << hullCells[0] << endl;
+
+        forAll(hullCells[0], cellI)
+        {
+            const cell& firstCurCell = cells_[hullCells[0][cellI]];
+
+            Info << "Cell: " << hullCells[0][cellI]
+                 << ": " << firstCurCell << endl;
+
+            forAll(firstCurCell, faceI)
+            {
+                Info << firstCurCell[faceI]
+                     << ": " << faces_[firstCurCell[faceI]] << endl;
+            }
+        }
+
+        const labelList& firstEdgeFaces = edgeFaces_[checkEdgeIndex[1]];
+
+        Info << nl << "First Edge Face Hull: " << firstEdgeFaces << endl;
+
+        forAll(firstEdgeFaces, indexI)
+        {
+            Info << firstEdgeFaces[indexI]
+                 << ": " << faces_[firstEdgeFaces[indexI]] << endl;
+        }
+
+        Info << nl << "Cells belonging to second Edge Hull: "
+             << hullCells[1] << endl;
+
+        forAll(hullCells[1], cellI)
+        {
+            const cell& secondCurCell = cells_[hullCells[1][cellI]];
+
+            Info << "Cell: " << hullCells[1][cellI]
+                 << ": " << secondCurCell << endl;
+
+            forAll(secondCurCell, faceI)
+            {
+                Info << secondCurCell[faceI]
+                     << ": " << faces_[secondCurCell[faceI]] << endl;
+            }
+        }
+
+        const labelList& secondEdgeFaces = edgeFaces_[checkEdgeIndex[2]];
+
+        Info << nl << "Second Edge Face Hull: " << secondEdgeFaces << endl;
+
+        forAll(secondEdgeFaces, indexI)
+        {
+            Info << secondEdgeFaces[indexI]
+                 << ": " << faces_[secondEdgeFaces[indexI]] << endl;
+        }
+
+        Info << endl;
+
+        Info << "Retained face: "
+             << faceToKeep[0] << ": "
+             << " owner: " << owner_[faceToKeep[0]]
+             << " neighbour: " << neighbour_[faceToKeep[0]]
+             << endl;
+
+        Info << "Discarded face: "
+             << faceToThrow[0] << ": "
+             << " owner: " << owner_[faceToThrow[0]]
+             << " neighbour: " << neighbour_[faceToThrow[0]]
+             << endl;
+
+        if (c1 != -1)
+        {
+            Info << "Retained face: "
+                 << faceToKeep[1] << ": "
+                 << " owner: " << owner_[faceToKeep[1]]
+                 << " neighbour: " << neighbour_[faceToKeep[1]]
+                 << endl;
+
+            Info << "Discarded face: "
+                 << faceToThrow[1] << ": "
+                 << " owner: " << owner_[faceToThrow[1]]
+                 << " neighbour: " << neighbour_[faceToThrow[1]]
+                 << endl;
+        }
+    }
+
+    // Ensure proper orientation for the two retained faces
+    FixedList<label,2> cellCheck(0);
+
+    if (owner_[faceToThrow[0]] == c0)
+    {
+        cellCheck[0] = neighbour_[faceToThrow[0]];
+
+        if (owner_[faceToKeep[0]] == c0)
+        {
+            if
+            (
+                (neighbour_[faceToThrow[0]] > neighbour_[faceToKeep[0]])
+             && (neighbour_[faceToKeep[0]] != -1)
+            )
+            {
+                // This face is to be flipped
+                faces_[faceToKeep[0]] =
+                (
+                    faces_[faceToKeep[0]].reverseFace()
+                );
+
+                owner_[faceToKeep[0]] = neighbour_[faceToKeep[0]];
+                neighbour_[faceToKeep[0]] = neighbour_[faceToThrow[0]];
+
+                setFlip(faceToKeep[0]);
+            }
+            else
+            {
+                if (neighbour_[faceToThrow[0]] != -1)
+                {
+                    // Keep orientation intact, and update the owner
+                    owner_[faceToKeep[0]] = neighbour_[faceToThrow[0]];
+                }
+                else
+                {
+                    // This face will need to be flipped and converted
+                    // to a boundary face. Flip it now, so that conversion
+                    // happens later.
+                    faces_[faceToKeep[0]] =
+                    (
+                        faces_[faceToKeep[0]].reverseFace()
+                    );
+
+                    owner_[faceToKeep[0]] = neighbour_[faceToKeep[0]];
+                    neighbour_[faceToKeep[0]] = -1;
+
+                    setFlip(faceToKeep[0]);
+                }
+            }
+        }
+        else
+        {
+            // Keep orientation intact, and update the neighbour
+            neighbour_[faceToKeep[0]] = neighbour_[faceToThrow[0]];
+        }
+    }
+    else
+    {
+        cellCheck[0] = owner_[faceToThrow[0]];
+
+        if (neighbour_[faceToKeep[0]] == c0)
+        {
+            if (owner_[faceToThrow[0]] < owner_[faceToKeep[0]])
+            {
+                // This face is to be flipped
+                faces_[faceToKeep[0]] =
+                (
+                    faces_[faceToKeep[0]].reverseFace()
+                );
+
+                neighbour_[faceToKeep[0]] = owner_[faceToKeep[0]];
+                owner_[faceToKeep[0]] = owner_[faceToThrow[0]];
+
+                setFlip(faceToKeep[0]);
+            }
+            else
+            {
+                // Keep orientation intact, and update the neighbour
+                neighbour_[faceToKeep[0]] = owner_[faceToThrow[0]];
+            }
+        }
+        else
+        {
+            // Keep orientation intact, and update the owner
+            owner_[faceToKeep[0]] = owner_[faceToThrow[0]];
+        }
+    }
+
+    if (c1 != -1)
+    {
+        if (owner_[faceToThrow[1]] == c1)
+        {
+            cellCheck[1] = neighbour_[faceToThrow[1]];
+
+            if (owner_[faceToKeep[1]] == c1)
+            {
+                if
+                (
+                    (neighbour_[faceToThrow[1]] > neighbour_[faceToKeep[1]])
+                 && (neighbour_[faceToKeep[1]] != -1)
+                )
+                {
+                    // This face is to be flipped
+                    faces_[faceToKeep[1]] =
+                    (
+                        faces_[faceToKeep[1]].reverseFace()
+                    );
+
+                    owner_[faceToKeep[1]] = neighbour_[faceToKeep[1]];
+                    neighbour_[faceToKeep[1]] = neighbour_[faceToThrow[1]];
+
+                    setFlip(faceToKeep[1]);
+                }
+                else
+                {
+                    if (neighbour_[faceToThrow[1]] != -1)
+                    {
+                        // Keep orientation intact, and update the owner
+                        owner_[faceToKeep[1]] = neighbour_[faceToThrow[1]];
+                    }
+                    else
+                    {
+                        // This face will need to be flipped and converted
+                        // to a boundary face. Flip it now, so that conversion
+                        // happens later.
+                        faces_[faceToKeep[1]] =
+                        (
+                            faces_[faceToKeep[1]].reverseFace()
+                        );
+
+                        owner_[faceToKeep[1]] = neighbour_[faceToKeep[1]];
+                        neighbour_[faceToKeep[1]] = -1;
+
+                        setFlip(faceToKeep[1]);
+                    }
+                }
+            }
+            else
+            {
+                // Keep orientation intact, and update the neighbour
+                neighbour_[faceToKeep[1]] = neighbour_[faceToThrow[1]];
+            }
+        }
+        else
+        {
+            cellCheck[1] = owner_[faceToThrow[1]];
+
+            if (neighbour_[faceToKeep[1]] == c1)
+            {
+                if (owner_[faceToThrow[1]] < owner_[faceToKeep[1]])
+                {
+                    // This face is to be flipped
+                    faces_[faceToKeep[1]] =
+                    (
+                        faces_[faceToKeep[1]].reverseFace()
+                    );
+
+                    neighbour_[faceToKeep[1]] = owner_[faceToKeep[1]];
+                    owner_[faceToKeep[1]] = owner_[faceToThrow[1]];
+
+                    setFlip(faceToKeep[1]);
+                }
+                else
+                {
+                    // Keep orientation intact, and update the neighbour
+                    neighbour_[faceToKeep[1]] = owner_[faceToThrow[1]];
+                }
+            }
+            else
+            {
+                // Keep orientation intact, and update the owner
+                owner_[faceToKeep[1]] = owner_[faceToThrow[1]];
+            }
+        }
+    }
+
+    // Remove orphaned faces
+    if (owner_[faceToKeep[0]] == -1)
+    {
+        removeFace(faceToKeep[0]);
+    }
+    else
+    if
+    (
+        (neighbour_[faceToKeep[0]] == -1)
+     && (whichPatch(faceToKeep[0]) < 0)
+    )
+    {
+        // Obtain a copy before adding the new face,
+        // since the reference might become invalid during list resizing.
+        face newFace = faces_[faceToKeep[0]];
+        label newOwn = owner_[faceToKeep[0]];
+        labelList newFaceEdges = faceEdges_[faceToKeep[0]];
+
+        // This face is being converted from interior to boundary. Remove
+        // from the interior list and add as a boundary face to the end.
+        label newFaceIndex =
+        (
+            insertFace
+            (
+                whichPatch(faceToThrow[0]),
+                newFace,
+                newOwn,
+                -1
+            )
+        );
+
+        // Add an entry for mapping
+        if (!modifiedFaces.found(newFaceIndex))
+        {
+            modifiedFaces.insert(newFaceIndex);
+        }
+
+        // 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],
+            newFaceIndex,
+            cells_[newOwn]
+        );
+
+        // Correct edgeFaces with the new face label.
+        forAll(newFaceEdges, edgeI)
+        {
+            meshOps::replaceLabel
+            (
+                faceToKeep[0],
+                newFaceIndex,
+                edgeFaces_[newFaceEdges[edgeI]]
+            );
+        }
+
+        // Renumber the neighbour so that this face is removed correctly.
+        neighbour_[faceToKeep[0]] = 0;
+        removeFace(faceToKeep[0]);
+    }
+
+    // Remove the unwanted faces in the cell(s) adjacent to this face,
+    // and correct the cells that contain discarded faces
+    const cell& cell_0 = cells_[c0];
+
+    forAll(cell_0,faceI)
+    {
+        if (cell_0[faceI] != fIndex && cell_0[faceI] != faceToKeep[0])
+        {
+           removeFace(cell_0[faceI]);
+        }
+    }
+
+    if (cellCheck[0] != -1)
+    {
+        meshOps::replaceLabel
+        (
+            faceToThrow[0],
+            faceToKeep[0],
+            cells_[cellCheck[0]]
+        );
+    }
+
+    // Remove the cell
+    removeCell(c0);
+
+    if (c1 == -1)
+    {
+        // Increment the surface-collapse counter
+        statistics_[6]++;
+    }
+    else
+    {
+        // Remove orphaned faces
+        if (owner_[faceToKeep[1]] == -1)
+        {
+            removeFace(faceToKeep[1]);
+        }
+        else
+        if
+        (
+            (neighbour_[faceToKeep[1]] == -1)
+         && (whichPatch(faceToKeep[1]) < 0)
+        )
+        {
+            // Obtain a copy before adding the new face,
+            // since the reference might become invalid during list resizing.
+            face newFace = faces_[faceToKeep[1]];
+            label newOwn = owner_[faceToKeep[1]];
+            labelList newFaceEdges = faceEdges_[faceToKeep[1]];
+
+            // This face is being converted from interior to boundary. Remove
+            // from the interior list and add as a boundary face to the end.
+            label newFaceIndex =
+            (
+                insertFace
+                (
+                    whichPatch(faceToThrow[1]),
+                    newFace,
+                    newOwn,
+                    -1
+                )
+            );
+
+            // Add an entry for mapping
+            if (!modifiedFaces.found(newFaceIndex))
+            {
+                modifiedFaces.insert(newFaceIndex);
+            }
+
+            // 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],
+                newFaceIndex,
+                cells_[newOwn]
+            );
+
+            // Correct edgeFaces with the new face label.
+            forAll(newFaceEdges, edgeI)
+            {
+                meshOps::replaceLabel
+                (
+                    faceToKeep[1],
+                    newFaceIndex,
+                    edgeFaces_[newFaceEdges[edgeI]]
+                );
+            }
+
+            // Renumber the neighbour so that this face is removed correctly.
+            neighbour_[faceToKeep[1]] = 0;
+            removeFace(faceToKeep[1]);
+        }
+
+        const cell& cell_1 = cells_[c1];
+
+        forAll(cell_1, faceI)
+        {
+            if (cell_1[faceI] != fIndex && cell_1[faceI] != faceToKeep[1])
+            {
+               removeFace(cell_1[faceI]);
+            }
+        }
+
+        if (cellCheck[1] != -1)
+        {
+            meshOps::replaceLabel
+            (
+                faceToThrow[1],
+                faceToKeep[1],
+                cells_[cellCheck[1]]
+            );
+        }
+
+        // Remove the cell
+        removeCell(c1);
+    }
+
+    // Move old / new points
+    oldPoints_[replacement[0]] = oldPoint[0];
+    oldPoints_[replacement[1]] = oldPoint[1];
+
+    points_[replacement[0]] = newPoint[0];
+    points_[replacement[1]] = newPoint[1];
+
+    // Finally remove the face
+    removeFace(fIndex);
+
+    // Write out VTK files after change
+    if (debug > 3)
+    {
+        labelHashSet vtkCells;
+
+        forAll(hullCells[0], cellI)
+        {
+            if (hullCells[0][cellI] == c0 || hullCells[0][cellI] == c1)
+            {
+                continue;
+            }
+
+            if (!vtkCells.found(hullCells[0][cellI]))
+            {
+                vtkCells.insert(hullCells[0][cellI]);
+            }
+        }
+
+        forAll(hullCells[1], cellI)
+        {
+            if (hullCells[1][cellI] == c0 || hullCells[1][cellI] == c1)
+            {
+                continue;
+            }
+
+            if (!vtkCells.found(hullCells[1][cellI]))
+            {
+                vtkCells.insert(hullCells[1][cellI]);
+            }
+        }
+
+        writeVTK
+        (
+            Foam::name(fIndex)
+          + "_Collapse_1",
+            vtkCells.toc()
+        );
+    }
+
+    // Specify that an old point-position
+    // has been modified, if necessary
+    if (collapseCase == 3 && c1 > -1)
+    {
+        labelList mP(2, -1);
+
+        mP[0] = original[0];
+        mP[1] = replacement[0];
+
+        modPoints_.set(replacement[0], mP);
+
+        mP[0] = original[1];
+        mP[1] = replacement[1];
+
+        modPoints_.set(replacement[1], mP);
+    }
+
+    // Fill-in candidate mapping information
+    labelList mC(2, -1);
+    mC[0] = c0, mC[1] = c1;
+
+    // Now that all old / new cells possess correct connectivity,
+    // compute mapping information.
+    forAll(hullCells, indexI)
+    {
+        forAll(hullCells[indexI], cellI)
+        {
+            label mcIndex = hullCells[indexI][cellI];
+
+            // Skip collapsed cells
+            if (mcIndex == c0 || mcIndex == c1)
+            {
+                continue;
+            }
+
+            // Set the mapping for this cell
+            setCellMapping(mcIndex, mC);
+        }
+    }
+
+    // Set face mapping information for modified faces
+    forAllConstIter(labelHashSet, modifiedFaces, fIter)
+    {
+        // Exclude deleted faces
+        if (faces_[fIter.key()].empty())
+        {
+            continue;
+        }
+
+        // Decide between default / weighted mapping
+        // based on boundary information
+        label fPatch = whichPatch(fIter.key());
+
+        if (fPatch == -1)
+        {
+            setFaceMapping(fIter.key());
+        }
+        else
+        {
+            // Fill-in candidate mapping information
+            labelList faceCandidates;
+
+            const labelList& fEdges = faceEdges_[fIter.key()];
+
+            forAll(fEdges, edgeI)
+            {
+                if (whichEdgePatch(fEdges[edgeI]) == fPatch)
+                {
+                    // Loop through associated edgeFaces
+                    const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+                    forAll(eFaces, faceI)
+                    {
+                        if
+                        (
+                            (eFaces[faceI] != fIter.key()) &&
+                            (whichPatch(eFaces[faceI]) == fPatch)
+                        )
+                        {
+                            faceCandidates.setSize
+                            (
+                                faceCandidates.size() + 1,
+                                eFaces[faceI]
+                            );
+                        }
+                    }
+                }
+            }
+
+            // Set the mapping for this face
+            setFaceMapping(fIter.key(), faceCandidates);
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Increment the counter
+    statistics_[4]++;
+
+    // Increment the number of modifications
+    statistics_[0]++;
+
+    // Return a succesful collapse
+    map.type() = collapseCase;
+
+    return map;
+}
+
+
+// Method for the collapse of an edge in 3D
+// - Returns a changeMap with a type specifying:
+//    -1: Collapse failed since max number of topo-changes was reached.
+//     0: Collapse could not be performed.
+//     1: Collapsed to first node.
+//     2: Collapsed to second node.
+//     3: Collapsed to mid-point (default)
+// - overRideCase is used to force a certain collapse configuration.
+//    -1: Use this value to let collapseEdge decide a case.
+//     1: Force collapse to first node.
+//     2: Force collapse to second node.
+//     3: Force collapse to mid-point
+// - checkOnly performs a feasibility check and returns without modifications.
+// - forceOp to force the collapse.
+const changeMap dynamicTopoFvMesh::collapseEdge
+(
+    const label eIndex,
+    label overRideCase,
+    bool checkOnly,
+    bool forceOp
+)
+{
+    // Edge collapse performs the following operations:
+    //      [1] Checks if either vertex of the edge is on a boundary
+    //      [2] Checks whether cells attached to deleted vertices will be valid
+    //          after the edge-collapse operation
+    //      [3] Deletes all cells surrounding this edge
+    //      [4] Deletes all faces surrounding this edge
+    //      [5] Deletes all faces surrounding the deleted vertex attached
+    //          to the cells in [3]
+    //      [6] Checks the orientation of faces connected to the retained
+    //          vertices
+    //      [7] Remove one of the vertices of the edge
+    //      Update faceEdges, edgeFaces and edgePoints information
+
+    // For 2D meshes, perform face-collapse
+    if (twoDMesh_)
+    {
+        return collapseQuadFace(eIndex, overRideCase, checkOnly);
+    }
+
+    // Figure out which thread this is...
+    label tIndex = self();
+
+    // Prepare the changeMaps
+    changeMap map, slaveMap;
+
+    if
+    (
+        (statistics_[0] > maxModifications_)
+     && (maxModifications_ > -1)
+    )
+    {
+        // Reached the max allowable topo-changes.
+        stack(tIndex).clear();
+
+        return map;
+    }
+
+    // Check if edgeRefinements are to be avoided on patch.
+    if (lengthEstimator().checkRefinementPatch(whichEdgePatch(eIndex)))
+    {
+        return map;
+    }
+
+    // Sanity check: Is the index legitimate?
+    if (eIndex < 0)
+    {
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    label overRideCase,\n"
+            "    bool checkOnly,\n"
+            "    bool forceOp\n"
+            ")\n"
+        )
+            << " Invalid index: " << eIndex
+            << abort(FatalError);
+    }
+
+    // Hull variables
+    bool found = false;
+    label replaceIndex = -1, m = edgePoints_[eIndex].size();
+
+    // Size up the hull lists
+    labelList cellHull(m, -1);
+    labelList faceHull(m, -1);
+    labelList edgeHull(m, -1);
+    labelListList ringEntities(4, labelList(m, -1));
+
+    // Construct a hull around this edge
+    meshOps::constructHull
+    (
+        eIndex,
+        faces_,
+        edges_,
+        cells_,
+        owner_,
+        neighbour_,
+        faceEdges_,
+        edgeFaces_,
+        edgePoints_,
+        edgeHull,
+        faceHull,
+        cellHull,
+        ringEntities
+    );
+
+    // Check whether points of the edge lies on a boundary
+    FixedList<label, 2> nBoundCurves(0), checkPoints(-1);
+    const FixedList<bool,2> edgeBoundary = checkEdgeBoundary(eIndex);
+
+    // Decide on collapseCase
+    label collapseCase = -1;
+
+    if (edgeBoundary[0] && !edgeBoundary[1])
+    {
+        collapseCase = 1;
+    }
+    else
+    if (!edgeBoundary[0] && edgeBoundary[1])
+    {
+        collapseCase = 2;
+    }
+    else
+    if (edgeBoundary[0] && edgeBoundary[1])
+    {
+        // If this is an interior edge with two boundary points.
+        // Bail out for now. If proximity based refinement is
+        // switched on, mesh may be sliced at this point.
+        if (whichEdgePatch(eIndex) == -1)
+        {
+            return map;
+        }
+
+        // Check if either point lies on a bounding curve
+        // Used to ensure that collapses happen towards bounding curves.
+        // If the edge itself is on a bounding curve, collapse is valid.
+        forAll(edges_[eIndex], pointI)
+        {
+            const labelList& pEdges = pointEdges_[edges_[eIndex][pointI]];
+
+            forAll(pEdges, edgeI)
+            {
+                if (checkBoundingCurve(pEdges[edgeI]))
+                {
+                    nBoundCurves[pointI]++;
+                }
+            }
+        }
+
+        // Pick the point which is connected to more bounding curves
+        if (nBoundCurves[0] > nBoundCurves[1])
+        {
+            collapseCase = 1;
+        }
+        else
+        if (nBoundCurves[1] > nBoundCurves[0])
+        {
+            collapseCase = 2;
+        }
+        else
+        {
+            // Bounding edge: collapseEdge can collapse this edge
+            collapseCase = 3;
+        }
+    }
+    else
+    {
+        // Looks like this is an interior edge.
+        // Collapse case [3] by default
+        collapseCase = 3;
+    }
+
+    // Perform an override if requested.
+    if (overRideCase != -1)
+    {
+        collapseCase = overRideCase;
+    }
+
+    // Configure the new point-position
+    point newPoint = vector::zero;
+    point oldPoint = vector::zero;
+
+    label collapsePoint = -1, replacePoint = -1;
+
+    switch (collapseCase)
+    {
+        case 1:
+        {
+            // Collapse to the first node
+            replacePoint = edges_[eIndex][0];
+            collapsePoint = edges_[eIndex][1];
+
+            newPoint = points_[replacePoint];
+            oldPoint = oldPoints_[replacePoint];
+
+            checkPoints[0] = collapsePoint;
+
+            break;
+        }
+
+        case 2:
+        {
+            // Collapse to the second node
+            replacePoint = edges_[eIndex][1];
+            collapsePoint = edges_[eIndex][0];
+
+            newPoint = points_[replacePoint];
+            oldPoint = oldPoints_[replacePoint];
+
+            checkPoints[0] = collapsePoint;
+
+            break;
+        }
+
+        case 3:
+        {
+            // Collapse to the mid-point
+            replacePoint = edges_[eIndex][1];
+            collapsePoint = edges_[eIndex][0];
+
+            newPoint =
+            (
+                0.5 *
+                (
+                    points_[replacePoint]
+                  + points_[collapsePoint]
+                )
+            );
+
+            oldPoint =
+            (
+                0.5 *
+                (
+                    oldPoints_[replacePoint]
+                  + oldPoints_[collapsePoint]
+                )
+            );
+
+            checkPoints[0] = replacePoint;
+            checkPoints[1] = collapsePoint;
+
+            break;
+        }
+
+        default:
+        {
+            // Don't think this will ever happen.
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    label overRideCase,\n"
+                "    bool checkOnly,\n"
+                "    bool forceOp\n"
+                ")\n"
+            )
+                << "Edge: " << eIndex << ": " << edges_[eIndex]
+                << ". Couldn't decide on collapseCase."
+                << abort(FatalError);
+
+            break;
+        }
+    }
+
+    // Loop through edges and check for feasibility of collapse
+    // Also, keep track of resulting cell quality,
+    // if collapse is indeed feasible
+    scalar collapseQuality(GREAT);
+    labelHashSet cellsChecked;
+
+    // Add all hull cells as 'checked',
+    // and therefore, feasible
+    forAll(cellHull, cellI)
+    {
+        if (cellHull[cellI] == -1)
+        {
+            continue;
+        }
+
+        cellsChecked.insert(cellHull[cellI]);
+    }
+
+    // Check collapsibility of cells around edges
+    // with the re-configured point
+    forAll(checkPoints, pointI)
+    {
+        if (checkPoints[pointI] == -1)
+        {
+            continue;
+        }
+
+        const labelList& checkPointEdges = pointEdges_[checkPoints[pointI]];
+
+        forAll(checkPointEdges, edgeI)
+        {
+            const labelList& eFaces = edgeFaces_[checkPointEdges[edgeI]];
+
+            // Build a list of cells to check
+            forAll(eFaces, faceI)
+            {
+                label own = owner_[eFaces[faceI]];
+                label nei = neighbour_[eFaces[faceI]];
+
+                // Check owner cell
+                if (!cellsChecked.found(own))
+                {
+                    // Check if a collapse is feasible
+                    if
+                    (
+                        checkCollapse
+                        (
+                            newPoint,
+                            oldPoint,
+                            checkPoints[pointI],
+                            own,
+                            cellsChecked,
+                            collapseQuality,
+                            forceOp
+                        )
+                    )
+                    {
+                        map.type() = 0;
+                        return map;
+                    }
+                }
+
+                // Check neighbour cell
+                if (!cellsChecked.found(nei) && nei != -1)
+                {
+                    // Check if a collapse is feasible
+                    if
+                    (
+                        checkCollapse
+                        (
+                            newPoint,
+                            oldPoint,
+                            checkPoints[pointI],
+                            nei,
+                            cellsChecked,
+                            collapseQuality,
+                            forceOp
+                        )
+                    )
+                    {
+                        map.type() = 0;
+                        return map;
+                    }
+                }
+            }
+        }
+    }
+
+    // Are we only performing checks?
+    if (checkOnly)
+    {
+        map.type() = collapseCase;
+
+        if (debug > 2)
+        {
+            Info << "Edge: " << eIndex
+                 << ":: " << edges_[eIndex] << nl
+                 << " collapseCase determined to be: "
+                 << collapseCase << nl
+                 << " Resulting quality: "
+                 << collapseQuality
+                 << endl;
+        }
+
+        return map;
+    }
+
+    // Update number of surface collapses, if necessary.
+    if (whichEdgePatch(eIndex) > -1)
+    {
+        statistics_[6]++;
+    }
+
+    // Define indices on the hull for removal / replacement
+    label removeEdgeIndex = -1, replaceEdgeIndex = -1;
+    label removeFaceIndex = -1, replaceFaceIndex = -1;
+
+    if (replacePoint == edges_[eIndex][0])
+    {
+        replaceEdgeIndex = 0;
+        replaceFaceIndex = 1;
+        removeEdgeIndex = 2;
+        removeFaceIndex = 3;
+    }
+    else
+    if (replacePoint == edges_[eIndex][1])
+    {
+        removeEdgeIndex = 0;
+        removeFaceIndex = 1;
+        replaceEdgeIndex = 2;
+        replaceFaceIndex = 3;
+    }
+    else
+    {
+        // Don't think this will ever happen.
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    label overRideCase,\n"
+            "    bool checkOnly,\n"
+            "    bool forceOp\n"
+            ")\n"
+        )
+            << "Edge: " << eIndex << ": " << edges_[eIndex]
+            << ". Couldn't decide on removal / replacement indices."
+            << abort(FatalError);
+    }
+
+    if (debug > 1)
+    {
+        Info << nl << nl
+             << "Edge: " << eIndex
+             << ": " << edges_[eIndex]
+             << " is to be collapsed. " << endl;
+
+        label epIndex = whichEdgePatch(eIndex);
+
+        Info << "Patch: ";
+
+        if (epIndex == -1)
+        {
+            Info << "Internal" << endl;
+        }
+        else
+        {
+            Info << boundaryMesh()[epIndex].name() << endl;
+        }
+
+        Info << " nBoundCurves: " << nBoundCurves << endl;
+        Info << " collapseCase: " << collapseCase << endl;
+
+        Info << " Resulting quality: " << collapseQuality << endl;
+
+        if (debug > 2)
+        {
+            Info << "Vertices: " << edgePoints_[eIndex] << endl;
+            Info << "Edges: " << edgeHull << endl;
+            Info << "Faces: " << faceHull << endl;
+            Info << "Cells: " << cellHull << endl;
+            Info << "replacePoint: " << replacePoint << endl;
+            Info << "collapsePoint: " << collapsePoint << endl;
+            Info << "checkPoints: " << checkPoints << endl;;
+            Info << "ringEntities (removed faces): " << endl;
+
+            forAll(ringEntities[removeFaceIndex], faceI)
+            {
+                label fIndex = ringEntities[removeFaceIndex][faceI];
+
+                if (fIndex == -1)
+                {
+                    continue;
+                }
+
+                Info << fIndex << ": " << faces_[fIndex] << endl;
+            }
+
+            Info << "ringEntities (removed edges): " << endl;
+            forAll(ringEntities[removeEdgeIndex], edgeI)
+            {
+                label ieIndex = ringEntities[removeEdgeIndex][edgeI];
+
+                if (ieIndex == -1)
+                {
+                    continue;
+                }
+
+                Info << ieIndex << ": " << edges_[ieIndex] << endl;
+            }
+
+            Info << "ringEntities (replacement faces): " << endl;
+            forAll(ringEntities[replaceFaceIndex], faceI)
+            {
+                label fIndex = ringEntities[replaceFaceIndex][faceI];
+
+                if (fIndex == -1)
+                {
+                    continue;
+                }
+
+                Info << fIndex << ": " << faces_[fIndex] << endl;
+            }
+
+            Info << "ringEntities (replacement edges): " << endl;
+            forAll(ringEntities[replaceEdgeIndex], edgeI)
+            {
+                label ieIndex = ringEntities[replaceEdgeIndex][edgeI];
+
+                if (ieIndex == -1)
+                {
+                    continue;
+                }
+
+                Info << ieIndex << ": " << edges_[ieIndex] << endl;
+            }
+
+            labelList& collapsePointEdges = pointEdges_[collapsePoint];
+
+            Info << "pointEdges (collapsePoint): ";
+
+            forAll(collapsePointEdges, edgeI)
+            {
+                Info << collapsePointEdges[edgeI] << " ";
+            }
+
+            Info << endl;
+
+            // Write out VTK files prior to change
+            if (debug > 3)
+            {
+                labelList vtkCells = cellsChecked.toc();
+
+                writeVTK
+                (
+                    Foam::name(eIndex)
+                  + '(' + Foam::name(edges_[eIndex][0])
+                  + ',' + Foam::name(edges_[eIndex][1]) + ')'
+                  + "_Collapse_0",
+                    vtkCells
+                );
+            }
+        }
+    }
+
+    // Maintain a list of modified faces for mapping
+    labelHashSet modifiedFaces;
+
+    // Renumber all hull faces and edges
+    forAll(faceHull, indexI)
+    {
+        // Loop through all faces of the edge to be removed
+        // and reassign them to the replacement edge
+        label edgeToRemove = ringEntities[removeEdgeIndex][indexI];
+        label faceToRemove = ringEntities[removeFaceIndex][indexI];
+        label cellToRemove = cellHull[indexI];
+        label replaceEdge = ringEntities[replaceEdgeIndex][indexI];
+        label replaceFace = ringEntities[replaceFaceIndex][indexI];
+
+        const labelList& rmvEdgeFaces = edgeFaces_[edgeToRemove];
+
+        // Replace edgePoints for all edges emanating from hullVertices
+        // except ring-edges; those are sized-down later
+        const labelList& hullPointEdges =
+        (
+            pointEdges_[edgePoints_[eIndex][indexI]]
+        );
+
+        forAll(hullPointEdges, edgeI)
+        {
+            if
+            (
+                findIndex
+                (
+                    edgePoints_[hullPointEdges[edgeI]],
+                    collapsePoint
+                ) != -1
+             && findIndex
+                (
+                    edgePoints_[hullPointEdges[edgeI]],
+                    replacePoint
+                ) == -1
+            )
+            {
+                meshOps::replaceLabel
+                (
+                    collapsePoint,
+                    replacePoint,
+                    edgePoints_[hullPointEdges[edgeI]]
+                );
+            }
+        }
+
+        forAll(rmvEdgeFaces, faceI)
+        {
+            // Replace edge labels for faces
+            meshOps::replaceLabel
+            (
+                edgeToRemove,
+                replaceEdge,
+                faceEdges_[rmvEdgeFaces[faceI]]
+            );
+
+            // Loop through faces associated with this edge,
+            // and renumber them as well.
+            const face& faceToCheck = faces_[rmvEdgeFaces[faceI]];
+
+            if ((replaceIndex = faceToCheck.which(collapsePoint)) > -1)
+            {
+                if (debug > 2)
+                {
+                    Info << "Renumbering face: "
+                         << rmvEdgeFaces[faceI] << ": "
+                         << faceToCheck << endl;
+                }
+
+                // Renumber the face...
+                faces_[rmvEdgeFaces[faceI]][replaceIndex] = replacePoint;
+
+                // Add an entry for mapping
+                if (!modifiedFaces.found(rmvEdgeFaces[faceI]))
+                {
+                    modifiedFaces.insert(rmvEdgeFaces[faceI]);
+                }
+            }
+
+            // Hull faces should be removed for the replacement edge
+            if (rmvEdgeFaces[faceI] == faceHull[indexI])
+            {
+                meshOps::sizeDownList
+                (
+                    faceHull[indexI],
+                    edgeFaces_[replaceEdge]
+                );
+
+                continue;
+            }
+
+            found = false;
+
+            // Need to avoid ring faces as well.
+            forAll(ringEntities[removeFaceIndex], faceII)
+            {
+                if
+                (
+                    rmvEdgeFaces[faceI]
+                 == ringEntities[removeFaceIndex][faceII]
+                )
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            // Size-up the replacement edge list if the face hasn't been found.
+            // These faces are connected to the edge slated for
+            // removal, but do not belong to the hull.
+            if (!found)
+            {
+                meshOps::sizeUpList
+                (
+                    rmvEdgeFaces[faceI],
+                    edgeFaces_[replaceEdge]
+                );
+            }
+        }
+
+        if (cellToRemove == -1)
+        {
+            continue;
+        }
+
+        // Size down edgeFaces for the ring edges
+        meshOps::sizeDownList
+        (
+            faceToRemove,
+            edgeFaces_[edgeHull[indexI]]
+        );
+
+        // Size down edgePoints for the ring edges
+        meshOps::sizeDownList
+        (
+            collapsePoint,
+            edgePoints_[edgeHull[indexI]]
+        );
+
+        // Ensure proper orientation of retained faces
+        if (owner_[faceToRemove] == cellToRemove)
+        {
+            if (owner_[replaceFace] == cellToRemove)
+            {
+                if
+                (
+                    (neighbour_[faceToRemove] > neighbour_[replaceFace])
+                 && (neighbour_[replaceFace] != -1)
+                )
+                {
+                    // This face is to be flipped
+                    faces_[replaceFace] = faces_[replaceFace].reverseFace();
+                    owner_[replaceFace] = neighbour_[replaceFace];
+                    neighbour_[replaceFace] = neighbour_[faceToRemove];
+
+                    setFlip(replaceFace);
+                }
+                else
+                if
+                (
+                    (neighbour_[faceToRemove] == -1) &&
+                    (neighbour_[replaceFace] != -1)
+                )
+                {
+                    // This interior face would need to be converted
+                    // to a boundary one, and flipped as well.
+                    face newFace = faces_[replaceFace].reverseFace();
+                    label newOwner = neighbour_[replaceFace];
+                    label newNeighbour = neighbour_[faceToRemove];
+                    labelList newFE = faceEdges_[replaceFace];
+
+                    label newFaceIndex =
+                    (
+                        insertFace
+                        (
+                            whichPatch(faceToRemove),
+                            newFace,
+                            newOwner,
+                            newNeighbour
+                        )
+                    );
+
+                    // Set this face aside for mapping
+                    if (!modifiedFaces.found(newFaceIndex))
+                    {
+                        modifiedFaces.insert(newFaceIndex);
+                    }
+
+                    // Ensure that all edges of this face are
+                    // on the boundary.
+                    forAll(newFE, edgeI)
+                    {
+                        if (whichEdgePatch(newFE[edgeI]) == -1)
+                        {
+                            edge newEdge = edges_[newFE[edgeI]];
+                            labelList newEF = edgeFaces_[newFE[edgeI]];
+                            labelList newEP = edgePoints_[newFE[edgeI]];
+
+                            // Need patch information for the new edge.
+                            // Find the corresponding edge in ringEntities.
+                            // Note that hullEdges doesn't need to be checked,
+                            // since they are common to both faces.
+                            label i =
+                            (
+                                findIndex
+                                (
+                                    ringEntities[replaceEdgeIndex],
+                                    newFE[edgeI]
+                                )
+                            );
+
+                            label repIndex =
+                            (
+                                whichEdgePatch
+                                (
+                                    ringEntities[removeEdgeIndex][i]
+                                )
+                            );
+
+                            // Insert the new edge
+                            label newEdgeIndex =
+                            (
+                                insertEdge
+                                (
+                                    repIndex,
+                                    newEdge,
+                                    newEF,
+                                    newEP
+                                )
+                            );
+
+                            // Replace faceEdges for all
+                            // connected faces.
+                            forAll(newEF, faceI)
+                            {
+                                meshOps::replaceLabel
+                                (
+                                    newFE[edgeI],
+                                    newEdgeIndex,
+                                    faceEdges_[newEF[faceI]]
+                                );
+                            }
+
+                            // Remove the edge
+                            removeEdge(newFE[edgeI]);
+
+                            // Replace faceEdges with new edge index
+                            newFE[edgeI] = newEdgeIndex;
+
+                            // Modify ringEntities
+                            ringEntities[replaceEdgeIndex][i] = newEdgeIndex;
+                        }
+                    }
+
+                    // Add the new faceEdges
+                    faceEdges_.append(newFE);
+
+                    // Replace edgeFaces with the new face index
+                    const labelList& newFEdges = faceEdges_[newFaceIndex];
+
+                    forAll(newFEdges, edgeI)
+                    {
+                        meshOps::replaceLabel
+                        (
+                            replaceFace,
+                            newFaceIndex,
+                            edgeFaces_[newFEdges[edgeI]]
+                        );
+                    }
+
+                    // Remove the face
+                    removeFace(replaceFace);
+
+                    // Replace label for the new owner
+                    meshOps::replaceLabel
+                    (
+                        replaceFace,
+                        newFaceIndex,
+                        cells_[newOwner]
+                    );
+
+                    // Modify ringEntities and replaceFace
+                    replaceFace = newFaceIndex;
+                    ringEntities[replaceFaceIndex][indexI] = newFaceIndex;
+                }
+                else
+                if
+                (
+                    (neighbour_[faceToRemove] == -1) &&
+                    (neighbour_[replaceFace] == -1)
+                )
+                {
+                    // Wierd overhanging cell. Since replaceFace
+                    // would be an orphan if this continued, remove
+                    // the face entirely.
+                    labelList rmFE = faceEdges_[replaceFace];
+
+                    forAll(rmFE, edgeI)
+                    {
+                        if
+                        (
+                            (edgeFaces_[rmFE[edgeI]].size() == 1) &&
+                            (edgeFaces_[rmFE[edgeI]][0] == replaceFace)
+                        )
+                        {
+                            // This edge has to be removed entirely.
+                            removeEdge(rmFE[edgeI]);
+
+                            label i =
+                            (
+                                findIndex
+                                (
+                                    ringEntities[replaceEdgeIndex],
+                                    rmFE[edgeI]
+                                )
+                            );
+
+                            // Modify ringEntities
+                            ringEntities[replaceEdgeIndex][i] = -1;
+                        }
+                        else
+                        {
+                            // Size-down edgeFaces
+                            meshOps::sizeDownList
+                            (
+                                replaceFace,
+                                edgeFaces_[rmFE[edgeI]]
+                            );
+                        }
+                    }
+
+                    removeFace(replaceFace);
+
+                    // Modify ringEntities and replaceFace
+                    replaceFace = -1;
+                    ringEntities[replaceFaceIndex][indexI] = -1;
+                }
+                else
+                {
+                    // Keep orientation intact, and update the owner
+                    owner_[replaceFace] = neighbour_[faceToRemove];
+                }
+            }
+            else
+            if (neighbour_[faceToRemove] == -1)
+            {
+                // This interior face would need to be converted
+                // to a boundary one, but with orientation intact.
+                face newFace = faces_[replaceFace];
+                label newOwner = owner_[replaceFace];
+                label newNeighbour = neighbour_[faceToRemove];
+                labelList newFE = faceEdges_[replaceFace];
+
+                label newFaceIndex =
+                (
+                    insertFace
+                    (
+                        whichPatch(faceToRemove),
+                        newFace,
+                        newOwner,
+                        newNeighbour
+                    )
+                );
+
+                // Set this face aside for mapping
+                if (!modifiedFaces.found(newFaceIndex))
+                {
+                    modifiedFaces.insert(newFaceIndex);
+                }
+
+                // Ensure that all edges of this face are
+                // on the boundary.
+                forAll(newFE, edgeI)
+                {
+                    if (whichEdgePatch(newFE[edgeI]) == -1)
+                    {
+                        edge newEdge = edges_[newFE[edgeI]];
+                        labelList newEF = edgeFaces_[newFE[edgeI]];
+                        labelList newEP = edgePoints_[newFE[edgeI]];
+
+                        // Need patch information for the new edge.
+                        // Find the corresponding edge in ringEntities.
+                        // Note that hullEdges doesn't need to be checked,
+                        // since they are common to both faces.
+                        label i =
+                        (
+                            findIndex
+                            (
+                                ringEntities[replaceEdgeIndex],
+                                newFE[edgeI]
+                            )
+                        );
+
+                        label repIndex =
+                        (
+                            whichEdgePatch
+                            (
+                                ringEntities[removeEdgeIndex][i]
+                            )
+                        );
+
+                        // Insert the new edge
+                        label newEdgeIndex =
+                        (
+                            insertEdge
+                            (
+                                repIndex,
+                                newEdge,
+                                newEF,
+                                newEP
+                            )
+                        );
+
+                        // Replace faceEdges for all
+                        // connected faces.
+                        forAll(newEF, faceI)
+                        {
+                            meshOps::replaceLabel
+                            (
+                                newFE[edgeI],
+                                newEdgeIndex,
+                                faceEdges_[newEF[faceI]]
+                            );
+                        }
+
+                        // Remove the edge
+                        removeEdge(newFE[edgeI]);
+
+                        // Replace faceEdges with new edge index
+                        newFE[edgeI] = newEdgeIndex;
+
+                        // Modify ringEntities
+                        ringEntities[replaceEdgeIndex][i] = newEdgeIndex;
+                    }
+                }
+
+                // Add the new faceEdges
+                faceEdges_.append(newFE);
+
+                // Replace edgeFaces with the new face index
+                const labelList& newFEdges = faceEdges_[newFaceIndex];
+
+                forAll(newFEdges, edgeI)
+                {
+                    meshOps::replaceLabel
+                    (
+                        replaceFace,
+                        newFaceIndex,
+                        edgeFaces_[newFEdges[edgeI]]
+                    );
+                }
+
+                // Remove the face
+                removeFace(replaceFace);
+
+                // Replace label for the new owner
+                meshOps::replaceLabel
+                (
+                    replaceFace,
+                    newFaceIndex,
+                    cells_[newOwner]
+                );
+
+                // Modify ringEntities and replaceFace
+                replaceFace = newFaceIndex;
+                ringEntities[replaceFaceIndex][indexI] = newFaceIndex;
+            }
+            else
+            {
+                // Keep orientation intact, and update the neighbour
+                neighbour_[replaceFace] = neighbour_[faceToRemove];
+            }
+
+            // Update the cell
+            if (neighbour_[faceToRemove] != -1)
+            {
+                meshOps::replaceLabel
+                (
+                    faceToRemove,
+                    replaceFace,
+                    cells_[neighbour_[faceToRemove]]
+                );
+            }
+        }
+        else
+        {
+            if (neighbour_[replaceFace] == cellToRemove)
+            {
+                if (owner_[faceToRemove] < owner_[replaceFace])
+                {
+                    // This face is to be flipped
+                    faces_[replaceFace] = faces_[replaceFace].reverseFace();
+                    neighbour_[replaceFace] = owner_[replaceFace];
+                    owner_[replaceFace] = owner_[faceToRemove];
+
+                    setFlip(replaceFace);
+                }
+                else
+                {
+                    // Keep orientation intact, and update the neighbour
+                    neighbour_[replaceFace] = owner_[faceToRemove];
+                }
+            }
+            else
+            {
+                // Keep orientation intact, and update the owner
+                owner_[replaceFace] = owner_[faceToRemove];
+            }
+
+            // Update the cell
+            meshOps::replaceLabel
+            (
+                faceToRemove,
+                replaceFace,
+                cells_[owner_[faceToRemove]]
+            );
+        }
+    }
+
+    // Remove all hull entities
+    forAll(faceHull, indexI)
+    {
+        label edgeToRemove = ringEntities[removeEdgeIndex][indexI];
+        label faceToRemove = ringEntities[removeFaceIndex][indexI];
+        label cellToRemove = cellHull[indexI];
+
+        if (cellToRemove != -1)
+        {
+            // Remove faceToRemove and associated faceEdges
+            removeFace(faceToRemove);
+
+            // Remove the hull cell
+            removeCell(cellToRemove);
+        }
+
+        // Remove the hull edge and associated edgeFaces
+        removeEdge(edgeToRemove);
+
+        // Remove the hull face
+        removeFace(faceHull[indexI]);
+    }
+
+    // Loop through pointEdges for the collapsePoint,
+    // and replace all occurrences with replacePoint.
+    // Size-up pointEdges for the replacePoint as well.
+    const labelList& pEdges = pointEdges_[collapsePoint];
+
+    forAll(pEdges, edgeI)
+    {
+        // Renumber edges
+        label edgeIndex = pEdges[edgeI];
+
+        if (edgeIndex != eIndex)
+        {
+            if (debug > 2)
+            {
+                Info << "Renumbering [edge]: "
+                     << edgeIndex << ": "
+                     << edges_[edgeIndex] << endl;
+            }
+
+            if (edges_[edgeIndex][0] == collapsePoint)
+            {
+                edges_[edgeIndex][0] = replacePoint;
+
+                meshOps::sizeUpList
+                (
+                    edgeIndex,
+                    pointEdges_[replacePoint]
+                );
+            }
+            else
+            if (edges_[edgeIndex][1] == collapsePoint)
+            {
+                edges_[edgeIndex][1] = replacePoint;
+
+                meshOps::sizeUpList
+                (
+                    edgeIndex,
+                    pointEdges_[replacePoint]
+                );
+            }
+            else
+            {
+                // Looks like pointEdges is inconsistent
+                FatalErrorIn
+                (
+                    "\n"
+                    "const changeMap dynamicTopoFvMesh::collapseEdge\n"
+                    "(\n"
+                    "    const label eIndex,\n"
+                    "    label overRideCase,\n"
+                    "    bool checkOnly,\n"
+                    "    bool forceOp\n"
+                    ")\n"
+                )
+                    << "pointEdges is inconsistent." << nl
+                    << "Point: " << collapsePoint << nl
+                    << "pointEdges: " << pEdges << nl
+                    << abort(FatalError);
+            }
+
+            // Loop through faces associated with this edge,
+            // and renumber them as well.
+            const labelList& eFaces = edgeFaces_[edgeIndex];
+
+            forAll(eFaces, faceI)
+            {
+                const face& faceToCheck = faces_[eFaces[faceI]];
+
+                if ((replaceIndex = faceToCheck.which(collapsePoint)) > -1)
+                {
+                    if (debug > 2)
+                    {
+                        Info << "Renumbering face: "
+                             << eFaces[faceI] << ": "
+                             << faceToCheck << endl;
+                    }
+
+                    // Renumber the face...
+                    faces_[eFaces[faceI]][replaceIndex] = replacePoint;
+
+                    // Set this face aside for mapping
+                    if (!modifiedFaces.found(eFaces[faceI]))
+                    {
+                        modifiedFaces.insert(eFaces[faceI]);
+                    }
+
+                    // Look for an edge on this face that doesn't
+                    // contain collapsePoint or replacePoint.
+                    label rplIndex = -1;
+                    const labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+                    forAll(fEdges, edgeI)
+                    {
+                        const edge& eCheck = edges_[fEdges[edgeI]];
+
+                        if
+                        (
+                            eCheck[0] != collapsePoint
+                         && eCheck[1] != collapsePoint
+                         && eCheck[0] != replacePoint
+                         && eCheck[1] != replacePoint
+                        )
+                        {
+                            rplIndex = fEdges[edgeI];
+                            break;
+                        }
+                    }
+
+                    // Modify edgePoints for this edge
+                    meshOps::replaceLabel
+                    (
+                        collapsePoint,
+                        replacePoint,
+                        edgePoints_[rplIndex]
+                    );
+                }
+            }
+        }
+    }
+
+    // At this point, edgePoints for the replacement edges are broken,
+    // but edgeFaces are consistent. So use this information to re-build
+    // edgePoints for all replacement edges.
+    forAll(ringEntities[replaceEdgeIndex], edgeI)
+    {
+        // If the ring edge was removed, don't bother.
+        if (ringEntities[replaceEdgeIndex][edgeI] == -1)
+        {
+            continue;
+        }
+
+        if (debug > 2)
+        {
+            Info << "Building edgePoints for edge: "
+                 << ringEntities[replaceEdgeIndex][edgeI] << ": "
+                 << edges_[ringEntities[replaceEdgeIndex][edgeI]]
+                 << endl;
+        }
+
+        buildEdgePoints(ringEntities[replaceEdgeIndex][edgeI]);
+    }
+
+    // Move old / new points
+    oldPoints_[replacePoint] = oldPoint;
+    points_[replacePoint] = newPoint;
+
+    // Remove the collapse point
+    removePoint(collapsePoint);
+
+    // Remove the edge
+    removeEdge(eIndex);
+
+    // For cell-mapping, exclude all hull-cells
+    forAll(cellHull, indexI)
+    {
+        if (cellsChecked.found(cellHull[indexI]))
+        {
+            cellsChecked.erase(cellHull[indexI]);
+        }
+    }
+
+    labelList mapCells = cellsChecked.toc();
+
+    // Write out VTK files after change
+    if (debug > 3)
+    {
+        writeVTK
+        (
+            Foam::name(eIndex)
+          + '(' + Foam::name(edges_[eIndex][0])
+          + ',' + Foam::name(edges_[eIndex][1]) + ')'
+          + "_Collapse_1",
+            mapCells
+        );
+    }
+
+    // Specify that an old point-position
+    // has been modified, if necessary
+    if (collapseCase == 3)
+    {
+        labelList mP(2, -1);
+
+        mP[0] = collapsePoint;
+        mP[1] = replacePoint;
+
+        modPoints_.set(replacePoint, mP);
+    }
+
+    // Now that all old / new cells possess correct connectivity,
+    // compute mapping information.
+    forAll(mapCells, cellI)
+    {
+        // Fill-in candidate mapping information
+        labelList mC(1, mapCells[cellI]);
+
+        // Set the mapping for this cell
+        setCellMapping(mapCells[cellI], mC);
+    }
+
+    // Set face mapping information for modified faces
+    forAllConstIter(labelHashSet, modifiedFaces, fIter)
+    {
+        // Exclude deleted faces
+        if (faces_[fIter.key()].empty())
+        {
+            continue;
+        }
+
+        // Decide between default / weighted mapping
+        // based on boundary information
+        label fPatch = whichPatch(fIter.key());
+
+        if (fPatch == -1)
+        {
+            setFaceMapping(fIter.key());
+        }
+        else
+        {
+            // Fill-in candidate mapping information
+            labelList faceCandidates;
+
+            const labelList& fEdges = faceEdges_[fIter.key()];
+
+            forAll(fEdges, edgeI)
+            {
+                if (whichEdgePatch(fEdges[edgeI]) == fPatch)
+                {
+                    // Loop through associated edgeFaces
+                    const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+                    forAll(eFaces, faceI)
+                    {
+                        if
+                        (
+                            (eFaces[faceI] != fIter.key()) &&
+                            (whichPatch(eFaces[faceI]) == fPatch)
+                        )
+                        {
+                            faceCandidates.setSize
+                            (
+                                faceCandidates.size() + 1,
+                                eFaces[faceI]
+                            );
+                        }
+                    }
+                }
+            }
+
+            // Set the mapping for this face
+            setFaceMapping(fIter.key(), faceCandidates);
+        }
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Increment the counter
+    statistics_[4]++;
+
+    // Increment the number of modifications
+    statistics_[0]++;
+
+    // Return a succesful collapse
+    map.type() = collapseCase;
+
+    return map;
+}
+
+
+// Remove the specified cells from the mesh,
+// and add internal faces/edges to the specified patch
+const changeMap dynamicTopoFvMesh::removeCells
+(
+    const labelList& cList,
+    const label patch
+)
+{
+    changeMap map;
+
+    labelHashSet pointsToRemove, edgesToRemove, facesToRemove;
+    Map<label> facesToConvert, edgesToConvert;
+
+    // First loop through all cells and accumulate
+    // a set of faces to be removed/converted.
+    forAll(cList, cellI)
+    {
+        const cell& cellToCheck = cells_[cList[cellI]];
+
+        forAll(cellToCheck, faceI)
+        {
+            label own = owner_[cellToCheck[faceI]];
+            label nei = neighbour_[cellToCheck[faceI]];
+
+            if (nei == -1)
+            {
+                if (!facesToRemove.found(cellToCheck[faceI]))
+                {
+                    facesToRemove.insert(cellToCheck[faceI]);
+                }
+            }
+            else
+            if
+            (
+                (findIndex(cList, own) != -1) &&
+                (findIndex(cList, nei) != -1)
+            )
+            {
+                if (!facesToRemove.found(cellToCheck[faceI]))
+                {
+                    facesToRemove.insert(cellToCheck[faceI]);
+                }
+            }
+            else
+            {
+                facesToConvert.set(cellToCheck[faceI], -1);
+            }
+        }
+    }
+
+    // Add all edges as candidates for conversion.
+    // Some of these will be removed altogether.
+    forAllConstIter(labelHashSet, facesToRemove, fIter)
+    {
+        const labelList& fEdges = faceEdges_[fIter.key()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (whichEdgePatch(fEdges[edgeI]) == patch)
+            {
+                // Make an identical map
+                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
+            }
+            else
+            {
+                edgesToConvert.set(fEdges[edgeI], -1);
+            }
+        }
+    }
+
+    forAllConstIter(Map<label>, facesToConvert, fIter)
+    {
+        const labelList& fEdges = faceEdges_[fIter.key()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (whichEdgePatch(fEdges[edgeI]) == patch)
+            {
+                // Make an identical map
+                edgesToConvert.set(fEdges[edgeI], fEdges[edgeI]);
+            }
+            else
+            {
+                edgesToConvert.set(fEdges[edgeI], -1);
+            }
+        }
+    }
+
+    // Build a list of edges to be removed.
+    forAllConstIter(Map<label>, edgesToConvert, eIter)
+    {
+        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+        bool allRemove = true;
+
+        forAll(eFaces, faceI)
+        {
+            if (facesToConvert.found(eFaces[faceI]))
+            {
+                allRemove = false;
+                break;
+            }
+        }
+
+        if (allRemove)
+        {
+            if (!edgesToRemove.found(eIter.key()))
+            {
+                edgesToRemove.insert(eIter.key());
+            }
+        }
+    }
+
+    // Weed-out the conversion list.
+    forAllConstIter(labelHashSet, edgesToRemove, eIter)
+    {
+        edgesToConvert.erase(eIter.key());
+    }
+
+    // Build a set of points to be removed.
+    if (!twoDMesh_)
+    {
+        forAllConstIter(labelHashSet, edgesToRemove, eIter)
+        {
+            const edge& edgeToCheck = edges_[eIter.key()];
+
+            forAll(edgeToCheck, pointI)
+            {
+                const labelList& pEdges = pointEdges_[edgeToCheck[pointI]];
+
+                bool allRemove = true;
+
+                forAll(pEdges, edgeI)
+                {
+                    if (!edgesToRemove.found(pEdges[edgeI]))
+                    {
+                        allRemove = false;
+                        break;
+                    }
+                }
+
+                if (allRemove)
+                {
+                    if (!pointsToRemove.found(edgeToCheck[pointI]))
+                    {
+                        pointsToRemove.insert(edgeToCheck[pointI]);
+                    }
+                }
+            }
+        }
+    }
+
+    forAllIter(Map<label>, edgesToConvert, eIter)
+    {
+        const labelList& eFaces = edgeFaces_[eIter.key()];
+
+        label nConvFaces = 0;
+
+        forAll(eFaces, faceI)
+        {
+            if (facesToConvert.found(eFaces[faceI]))
+            {
+                nConvFaces++;
+            }
+        }
+
+        if (nConvFaces > 2)
+        {
+            Info << "Invalid conversion. Bailing out." << endl;
+            return map;
+        }
+    }
+
+    // Write out candidates for post-processing
+    if (debug > 2)
+    {
+        writeVTK("pointsToRemove", pointsToRemove.toc(), 0);
+        writeVTK("edgesToRemove", edgesToRemove.toc(), 1);
+        writeVTK("facesToRemove", facesToRemove.toc(), 2);
+        writeVTK("cellsToRemove", cList, 3);
+        writeVTK("edgesToConvert", edgesToConvert.toc(), 1);
+        writeVTK("facesToConvert", facesToConvert.toc(), 2);
+    }
+
+    // Loop through all faces for conversion, check orientation
+    // and create new faces in their place.
+    forAllIter(Map<label>, facesToConvert, fIter)
+    {
+        // Check if this internal face is oriented properly.
+        face newFace;
+        label newOwner = -1;
+        labelList fEdges = faceEdges_[fIter.key()];
+
+        if (findIndex(cList, neighbour_[fIter.key()]) != -1)
+        {
+            // Orientation is correct
+            newFace = faces_[fIter.key()];
+            newOwner = owner_[fIter.key()];
+        }
+        else
+        if (findIndex(cList, owner_[fIter.key()]) != -1)
+        {
+            // Face is to be reversed.
+            newFace = faces_[fIter.key()].reverseFace();
+            newOwner = neighbour_[fIter.key()];
+
+            setFlip(fIter.key());
+        }
+        else
+        {
+            // Something's terribly wrong
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::removeCells\n"
+                "(\n"
+                "    const labelList& cList,\n"
+                "    const label patch\n"
+                ")\n"
+            )
+                << nl << " Invalid mesh. "
+                << abort(FatalError);
+        }
+
+        // Insert the reconfigured face at the boundary.
+        fIter() =
+        (
+            insertFace
+            (
+                patch,
+                newFace,
+                newOwner,
+                -1
+            )
+        );
+
+        // Add the faceEdges entry.
+        // Edges will be corrected later.
+        faceEdges_.append(fEdges);
+
+        // Add this face to the map.
+        map.addFace(fIter());
+
+        // Replace cell with the new face label
+        meshOps::replaceLabel
+        (
+            fIter.key(),
+            fIter(),
+            cells_[newOwner]
+        );
+
+        // Remove the internal face.
+        removeFace(fIter.key());
+    }
+
+    // Create a new edge for each converted edge
+    forAllIter(Map<label>, edgesToConvert, eIter)
+    {
+        if (eIter() == -1)
+        {
+            // Create copies before appending.
+            edge newEdge = edges_[eIter.key()];
+            labelList eFaces = edgeFaces_[eIter.key()];
+            labelList ePoints = edgePoints_[eIter.key()];
+
+            eIter() =
+            (
+                insertEdge
+                (
+                    patch,
+                    newEdge,
+                    eFaces,
+                    ePoints
+                )
+            );
+
+            // Add this edge to the map.
+            map.addEdge(eIter());
+
+            // Remove the edge
+            removeEdge(eIter.key());
+        }
+    }
+
+    // Loop through all faces for conversion, and replace edgeFaces.
+    forAllConstIter(Map<label>, facesToConvert, fIter)
+    {
+        // Make a copy, because this list is going to
+        // be modified within this loop.
+        labelList fEdges = faceEdges_[fIter()];
+
+        forAll(fEdges, edgeI)
+        {
+            if (edgesToConvert.found(fEdges[edgeI]))
+            {
+                meshOps::replaceLabel
+                (
+                    fIter.key(),
+                    fIter(),
+                    edgeFaces_[edgesToConvert[fEdges[edgeI]]]
+                );
+
+                meshOps::replaceLabel
+                (
+                    fEdges[edgeI],
+                    edgesToConvert[fEdges[edgeI]],
+                    faceEdges_[fIter()]
+                );
+            }
+        }
+    }
+
+    // Loop through all edges for conversion, and size-down edgeFaces.
+    forAllConstIter(Map<label>, edgesToConvert, eIter)
+    {
+        // Make a copy, because this list is going to
+        // be modified within this loop.
+        labelList eFaces = edgeFaces_[eIter()];
+
+        forAll(eFaces, faceI)
+        {
+            if (facesToRemove.found(eFaces[faceI]))
+            {
+                meshOps::sizeDownList
+                (
+                    eFaces[faceI],
+                    edgeFaces_[eIter()]
+                );
+            }
+
+            // Replace old edges with new ones.
+            labelList& fEdges = faceEdges_[eFaces[faceI]];
+
+            forAll(fEdges, edgeI)
+            {
+                if (edgesToConvert.found(fEdges[edgeI]))
+                {
+                    fEdges[edgeI] = edgesToConvert[fEdges[edgeI]];
+                }
+            }
+        }
+    }
+
+    // At this point, edgeFaces is consistent.
+    // Correct edge-points for all converted edges
+    if (!twoDMesh_)
+    {
+        forAllConstIter(Map<label>, edgesToConvert, eIter)
+        {
+            buildEdgePoints(eIter());
+        }
+    }
+
+    // Remove unwanted faces
+    forAllConstIter(labelHashSet, facesToRemove, fIter)
+    {
+        removeFace(fIter.key());
+    }
+
+    // Remove unwanted edges
+    forAllConstIter(labelHashSet, edgesToRemove, eIter)
+    {
+        removeEdge(eIter.key());
+    }
+
+    // Remove unwanted points
+    forAllConstIter(labelHashSet, pointsToRemove, pIter)
+    {
+        removePoint(pIter.key());
+    }
+
+    // Remove all cells
+    forAll(cList, cellI)
+    {
+        removeCell(cList[cellI]);
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    return map;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
new file mode 100644
index 000000000..f8d37a7e5
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/edgeSwap.C
@@ -0,0 +1,3099 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "Stack.H"
+#include "triFace.H"
+#include "objectMap.H"
+#include "changeMap.H"
+#include "triPointRef.H"
+#include "linePointRef.H"
+#include "multiThreader.H"
+#include "dynamicTopoFvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Perform a Delaunay test on an internal face
+bool dynamicTopoFvMesh::testDelaunay
+(
+    const label fIndex
+) const
+{
+    bool failed = false;
+    label eIndex = -1, pIndex = -1, fLabel = -1;
+    FixedList<bool,2> foundTriFace(false);
+    FixedList<FixedList<label,3>,2> triFaces(FixedList<label,3>(-1));
+
+    // Boundary faces are discarded.
+    if (whichPatch(fIndex) > -1)
+    {
+        {
+            return failed;
+        }
+    }
+
+    {
+        const labelList& fEdges = faceEdges_[fIndex];
+
+        forAll(fEdges, edgeI)
+        {
+            // Break out if both triangular faces are found
+            if (foundTriFace[0] && foundTriFace[1])
+            {
+                break;
+            }
+
+            // Obtain edgeFaces for this edge
+            const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+            forAll(eFaces, faceI)
+            {
+                const face& thisFace = faces_[eFaces[faceI]];
+
+                if (thisFace.size() == 3)
+                {
+                    if (foundTriFace[0])
+                    {
+                        // Update the second face.
+                        triFaces[1][0] = thisFace[0];
+                        triFaces[1][1] = thisFace[1];
+                        triFaces[1][2] = thisFace[2];
+
+                        foundTriFace[1] = true;
+
+                        // Take this edge
+                        eIndex = fEdges[edgeI];
+                    }
+                    else
+                    {
+                        // Update the first face.
+                        triFaces[0][0] = thisFace[0];
+                        triFaces[0][1] = thisFace[1];
+                        triFaces[0][2] = thisFace[2];
+
+                        foundTriFace[0] = true;
+
+                        fLabel = eFaces[faceI];
+                    }
+                }
+            }
+        }
+    }
+
+    // Obtain point references for the first face
+    point a = points_[triFaces[0][0]];
+
+    const face& faceToCheck = faces_[fLabel];
+
+    vector cCentre =
+    (
+        triPointRef
+        (
+            points_[faceToCheck[0]],
+            points_[faceToCheck[1]],
+            points_[faceToCheck[2]]
+        ).circumCentre()
+    );
+
+    point otherPoint = vector::zero;
+    scalar rSquared = (a - cCentre)&(a - cCentre);
+
+    // Find the isolated point on the second face
+    {
+        const edge& e = edges_[eIndex];
+
+        // Check the first point
+        if (triFaces[1][0] != e.start() && triFaces[1][0] != e.end())
+        {
+            pIndex = triFaces[1][0];
+        }
+
+        // Check the second point
+        if (triFaces[1][1] != e.start() && triFaces[1][1] != e.end())
+        {
+            pIndex = triFaces[1][1];
+        }
+
+        // Check the third point
+        if (triFaces[1][2] != e.start() && triFaces[1][2] != e.end())
+        {
+            pIndex = triFaces[1][2];
+        }
+
+        // ...and determine whether it lies in this circle
+        otherPoint = points_[pIndex];
+    }
+
+    if (((otherPoint - cCentre)&(otherPoint - cCentre)) < rSquared)
+    {
+        // Failed the test.
+        failed = true;
+    }
+
+    return failed;
+}
+
+
+// Method for the swapping of a quad-face in 2D
+// - Returns a changeMap with a type specifying:
+//     1: Swap sequence was successful
+//    -1: Swap sequence failed
+const changeMap dynamicTopoFvMesh::swapQuadFace
+(
+    const label fIndex
+)
+{
+    changeMap map;
+
+    face f;
+    bool found = false;
+    label commonIndex = -1;
+    FixedList<label,4> otherPointIndex(-1), nextToOtherPoint(-1);
+    FixedList<label,2> c0BdyIndex, c0IntIndex, c1BdyIndex, c1IntIndex;
+    FixedList<face,2>  c0BdyFace,  c0IntFace,  c1BdyFace,  c1IntFace;
+    FixedList<label,2> commonEdgeIndex(-1);
+    FixedList<edge,2>  commonEdges;
+    FixedList<label,4> otherEdgeIndex(-1);
+    FixedList<label,4> commonFaceIndex(-1), cornerEdgeIndex(-1);
+    FixedList<face,4>  commonFaces(face(3)), commonIntFaces(face(4));
+    FixedList<label,4> commonIntFaceIndex(-1);
+    FixedList<bool,2> foundTriFace0(false), foundTriFace1(false);
+    FixedList<face,2> triFaces0(face(3)), triFaces1(face(3));
+
+    // Get the two cells on either side...
+    label c0 = owner_[fIndex];
+    label c1 = neighbour_[fIndex];
+
+    // Prepare two new cells
+    FixedList<cell, 2> newCell(cell(5));
+
+    // Need to find common faces and edges...
+    // At the end of this loop, commonFaces [0] & [1] share commonEdge[0]
+    // and commonFaces [2] & [3] share commonEdge[1]
+    // Also, commonFaces[0] & [2] are connected to cell[0],
+    // and commonFaces[1] & [3] are connected to cell[1]
+    const labelList& fEdges = faceEdges_[fIndex];
+
+    forAll(fEdges, edgeI)
+    {
+        // Break out if all triangular faces are found
+        if
+        (
+            foundTriFace0[0] && foundTriFace0[1] &&
+            foundTriFace1[0] && foundTriFace1[1]
+        )
+        {
+            break;
+        }
+
+        // Obtain edgeFaces for this edge
+        const labelList& eFaces = edgeFaces_[fEdges[edgeI]];
+
+        forAll(eFaces, faceI)
+        {
+            const face& eFace = faces_[eFaces[faceI]];
+
+            if (eFace.size() == 3)
+            {
+                // Found a triangular face. Determine which cell it belongs to.
+                if (owner_[eFaces[faceI]] == c0)
+                {
+                    if (foundTriFace0[0])
+                    {
+                        // Update the second face on cell[0].
+                        commonIndex = 2;
+                        foundTriFace0[1] = true;
+
+                        if (foundTriFace1[1])
+                        {
+                            commonEdgeIndex[1] = fEdges[edgeI];
+                            commonEdges[1] = edges_[fEdges[edgeI]];
+                        }
+                    }
+                    else
+                    {
+                        // Update the first face on cell[0].
+                        commonIndex = 0;
+                        foundTriFace0[0] = true;
+
+                        if (foundTriFace1[0])
+                        {
+                            commonEdgeIndex[0] = fEdges[edgeI];
+                            commonEdges[0] = edges_[fEdges[edgeI]];
+                        }
+                    }
+                }
+                else
+                {
+                    if (foundTriFace1[0])
+                    {
+                        // Update the second face on cell[1].
+                        commonIndex = 3;
+                        foundTriFace1[1] = true;
+
+                        if (foundTriFace0[1])
+                        {
+                            commonEdgeIndex[1] = fEdges[edgeI];
+                            commonEdges[1] = edges_[fEdges[edgeI]];
+                        }
+                    }
+                    else
+                    {
+                        // Update the first face on cell[1].
+                        commonIndex = 1;
+                        foundTriFace1[0] = true;
+
+                        if (foundTriFace0[0])
+                        {
+                            commonEdgeIndex[0] = fEdges[edgeI];
+                            commonEdges[0] = edges_[fEdges[edgeI]];
+                        }
+                    }
+                }
+
+                // Store the face and index
+                commonFaces[commonIndex][0] = eFace[0];
+                commonFaces[commonIndex][1] = eFace[1];
+                commonFaces[commonIndex][2] = eFace[2];
+
+                commonFaceIndex[commonIndex] = eFaces[faceI];
+            }
+        }
+    }
+
+    // Find the interior/boundary faces.
+    meshOps::findPrismFaces
+    (
+        fIndex,
+        c0,
+        faces_,
+        cells_,
+        neighbour_,
+        c0BdyFace,
+        c0BdyIndex,
+        c0IntFace,
+        c0IntIndex
+    );
+
+    meshOps::findPrismFaces
+    (
+        fIndex,
+        c1,
+        faces_,
+        cells_,
+        neighbour_,
+        c1BdyFace,
+        c1BdyIndex,
+        c1IntFace,
+        c1IntIndex
+    );
+
+    // Find the points that don't lie on shared edges
+    // and the points next to them (for orientation)
+    meshOps::findIsolatedPoint
+    (
+        commonFaces[1],
+        commonEdges[0],
+        otherPointIndex[1],
+        nextToOtherPoint[1]
+    );
+
+    meshOps::findIsolatedPoint
+    (
+        commonFaces[0],
+        commonEdges[0],
+        otherPointIndex[0],
+        nextToOtherPoint[0]
+    );
+
+    meshOps::findIsolatedPoint
+    (
+        commonFaces[2],
+        commonEdges[1],
+        otherPointIndex[2],
+        nextToOtherPoint[2]
+    );
+
+    meshOps::findIsolatedPoint
+    (
+        commonFaces[3],
+        commonEdges[1],
+        otherPointIndex[3],
+        nextToOtherPoint[3]
+    );
+
+    // Ensure that the configuration will be valid
+    // using old point-positions. A simple area-based
+    // calculation should suffice.
+    FixedList<face, 2> triFaceOldPoints(face(3));
+
+    triFaceOldPoints[0][0] = otherPointIndex[0];
+    triFaceOldPoints[0][1] = nextToOtherPoint[0];
+    triFaceOldPoints[0][2] = otherPointIndex[1];
+
+    triFaceOldPoints[1][0] = otherPointIndex[1];
+    triFaceOldPoints[1][1] = nextToOtherPoint[1];
+    triFaceOldPoints[1][2] = otherPointIndex[0];
+
+    // Assume XY plane here
+    vector n = vector(0,0,1);
+
+    forAll(triFaceOldPoints, faceI)
+    {
+        // Assume that centre-plane passes through the origin.
+        vector xf, nf;
+
+        meshOps::faceCentre
+        (
+            triFaceOldPoints[faceI],
+            oldPoints_,
+            xf
+        );
+
+        meshOps::faceNormal
+        (
+            triFaceOldPoints[faceI],
+            oldPoints_,
+            nf
+        );
+
+        if ((((xf & n) * n) & nf) < 0.0)
+        {
+            // This will yield an inverted cell. Bail out.
+            return map;
+        }
+    }
+
+    // Find the other two edges on the face being flipped
+    forAll(fEdges, edgeI)
+    {
+        if
+        (
+            fEdges[edgeI] != commonEdgeIndex[0] &&
+            fEdges[edgeI] != commonEdgeIndex[1]
+        )
+        {
+            // Obtain a reference to this edge
+            const edge& eThis = edges_[fEdges[edgeI]];
+
+            if
+            (
+                eThis[0] == nextToOtherPoint[0]
+             || eThis[1] == nextToOtherPoint[0]
+            )
+            {
+                otherEdgeIndex[0] = fEdges[edgeI];
+            }
+            else
+            {
+                otherEdgeIndex[1] = fEdges[edgeI];
+            }
+        }
+    }
+
+    // At the end of this loop, commonIntFaces [0] & [1] share otherEdges[0]
+    // and commonIntFaces [2] & [3] share the otherEdges[1],
+    // where [0],[2] lie on cell[0] and [1],[3] lie on cell[1]
+    found = false;
+
+    const labelList& e1 = faceEdges_[c0IntIndex[0]];
+
+    forAll(e1,edgeI)
+    {
+        if (e1[edgeI] == otherEdgeIndex[0])
+        {
+            commonIntFaces[0] = c0IntFace[0];
+            commonIntFaces[2] = c0IntFace[1];
+            commonIntFaceIndex[0] = c0IntIndex[0];
+            commonIntFaceIndex[2] = c0IntIndex[1];
+            found = true; break;
+        }
+    }
+
+    if (!found)
+    {
+        // The edge was not found before
+        commonIntFaces[0] = c0IntFace[1];
+        commonIntFaces[2] = c0IntFace[0];
+        commonIntFaceIndex[0] = c0IntIndex[1];
+        commonIntFaceIndex[2] = c0IntIndex[0];
+    }
+
+    found = false;
+
+    const labelList& e3 = faceEdges_[c1IntIndex[0]];
+
+    forAll(e3,edgeI)
+    {
+        if (e3[edgeI] == otherEdgeIndex[0])
+        {
+            commonIntFaces[1] = c1IntFace[0];
+            commonIntFaces[3] = c1IntFace[1];
+            commonIntFaceIndex[1] = c1IntIndex[0];
+            commonIntFaceIndex[3] = c1IntIndex[1];
+            found = true; break;
+        }
+    }
+
+    if (!found)
+    {
+        // The edge was not found before
+        commonIntFaces[1] = c1IntFace[1];
+        commonIntFaces[3] = c1IntFace[0];
+        commonIntFaceIndex[1] = c1IntIndex[1];
+        commonIntFaceIndex[3] = c1IntIndex[0];
+    }
+
+    // Find two common edges between quad/quad faces
+    meshOps::findCommonEdge
+    (
+        c0IntIndex[0],
+        c0IntIndex[1],
+        faceEdges_,
+        otherEdgeIndex[2]
+    );
+
+    meshOps::findCommonEdge
+    (
+        c1IntIndex[0],
+        c1IntIndex[1],
+        faceEdges_,
+        otherEdgeIndex[3]
+    );
+
+    // Find four common edges between quad/tri faces
+    meshOps::findCommonEdge
+    (
+        commonFaceIndex[1],
+        commonIntFaceIndex[1],
+        faceEdges_,
+        cornerEdgeIndex[0]
+    );
+
+    meshOps::findCommonEdge
+    (
+        commonFaceIndex[3],
+        commonIntFaceIndex[1],
+        faceEdges_,
+        cornerEdgeIndex[1]
+    );
+
+    meshOps::findCommonEdge
+    (
+        commonFaceIndex[0],
+        commonIntFaceIndex[2],
+        faceEdges_,
+        cornerEdgeIndex[2]
+    );
+
+    meshOps::findCommonEdge
+    (
+        commonFaceIndex[2],
+        commonIntFaceIndex[2],
+        faceEdges_,
+        cornerEdgeIndex[3]
+    );
+
+    // Perform a few debug calls before modifications
+    if (debug > 1)
+    {
+        Info << nl << nl << "Face: " << fIndex
+             << " needs to be flipped. " << endl;
+
+        Info << "Cell[0]: " << c0 << ": " << cells_[c0] << endl;
+        Info << "Cell[1]: " << c1 << ": " << cells_[c1] << endl;
+
+        if (debug > 2)
+        {
+            Info << "Common Faces: Set 1: "
+                 << commonFaceIndex[0] << ": " << commonFaces[0] << ", "
+                 << commonFaceIndex[1] << ": " << commonFaces[1] << endl;
+
+            Info << "Common Faces: Set 2: "
+                 << commonFaceIndex[2] << ": " << commonFaces[2] << ", "
+                 << commonFaceIndex[3] << ": " << commonFaces[3] << endl;
+
+            Info << "Old face: " << faces_[fIndex] << endl;
+            Info << "Old faceEdges: " << faceEdges_[fIndex] << endl;
+        }
+
+        // Write out VTK files before change
+        if (debug > 3)
+        {
+            labelList cellHull(2, -1);
+
+            cellHull[0] = c0;
+            cellHull[1] = c1;
+
+            writeVTK
+            (
+                Foam::name(fIndex)
+              + "_Swap_0",
+                cellHull
+            );
+        }
+    }
+
+    // Modify the five faces belonging to this hull
+    face newFace = faces_[fIndex];
+    labelList newFEdges = faceEdges_[fIndex];
+    FixedList<face, 4> newBdyFace(face(3));
+    FixedList<edge, 2> newEdges;
+
+    // Assign current faces
+    forAll(newBdyFace, faceI)
+    {
+        newBdyFace[faceI] = faces_[commonFaceIndex[faceI]];
+    }
+
+    label c0count=0, c1count=0;
+
+    // Size down edgeFaces for the original face
+    meshOps::sizeDownList
+    (
+        fIndex,
+        edgeFaces_[otherEdgeIndex[0]]
+    );
+
+    meshOps::sizeDownList
+    (
+        fIndex,
+        edgeFaces_[otherEdgeIndex[1]]
+    );
+
+    // Size up edgeFaces for the face after flipping
+    meshOps::sizeUpList
+    (
+        fIndex,
+        edgeFaces_[otherEdgeIndex[2]]
+    );
+
+    meshOps::sizeUpList
+    (
+        fIndex,
+        edgeFaces_[otherEdgeIndex[3]]
+    );
+
+    // Replace edgeFaces and faceEdges for the
+    // four (out of 8 total) corner edges of this hull.
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[0],
+        cornerEdgeIndex[2],
+        faceEdges_[commonFaceIndex[1]]
+    );
+
+    meshOps::replaceLabel
+    (
+        commonFaceIndex[1],
+        commonFaceIndex[0],
+        edgeFaces_[cornerEdgeIndex[0]]
+    );
+
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[1],
+        cornerEdgeIndex[3],
+        faceEdges_[commonFaceIndex[3]]
+    );
+
+    meshOps::replaceLabel
+    (
+        commonFaceIndex[3],
+        commonFaceIndex[2],
+        edgeFaces_[cornerEdgeIndex[1]]
+    );
+
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[2],
+        cornerEdgeIndex[0],
+        faceEdges_[commonFaceIndex[0]]
+    );
+
+    meshOps::replaceLabel
+    (
+        commonFaceIndex[0],
+        commonFaceIndex[1],
+        edgeFaces_[cornerEdgeIndex[2]]
+    );
+
+    meshOps::replaceLabel
+    (
+        cornerEdgeIndex[3],
+        cornerEdgeIndex[1],
+        faceEdges_[commonFaceIndex[2]]
+    );
+
+    meshOps::replaceLabel
+    (
+        commonFaceIndex[2],
+        commonFaceIndex[3],
+        edgeFaces_[cornerEdgeIndex[3]]
+    );
+
+    // Define parameters for the new flipped face
+    newFace[0] = otherPointIndex[0];
+    newFace[1] = otherPointIndex[1];
+    newFace[2] = otherPointIndex[3];
+    newFace[3] = otherPointIndex[2];
+
+    newFEdges[0] = otherEdgeIndex[2];
+    newFEdges[1] = commonEdgeIndex[0];
+    newFEdges[2] = otherEdgeIndex[3];
+    newFEdges[3] = commonEdgeIndex[1];
+
+    newCell[0][c0count++] = fIndex;
+    newCell[1][c1count++] = fIndex;
+
+    owner_[fIndex] = c0;
+    neighbour_[fIndex] = c1;
+
+    // Both commonEdges need to be renumbered.
+    newEdges[0][0] = otherPointIndex[0];
+    newEdges[0][1] = otherPointIndex[1];
+
+    newEdges[1][0] = otherPointIndex[3];
+    newEdges[1][1] = otherPointIndex[2];
+
+    // Four modified boundary faces need to be constructed,
+    // but right-handedness is also important.
+    // Take a cue from the existing boundary-face orientation
+
+    // Zeroth boundary face - Owner c[0], Neighbour -1
+    newBdyFace[0][0] = otherPointIndex[0];
+    newBdyFace[0][1] = nextToOtherPoint[0];
+    newBdyFace[0][2] = otherPointIndex[1];
+    newCell[0][c0count++] = commonFaceIndex[0];
+    owner_[commonFaceIndex[0]] = c0;
+    neighbour_[commonFaceIndex[0]] = -1;
+
+    // First boundary face - Owner c[1], Neighbour -1
+    newBdyFace[1][0] = otherPointIndex[1];
+    newBdyFace[1][1] = nextToOtherPoint[1];
+    newBdyFace[1][2] = otherPointIndex[0];
+    newCell[1][c1count++] = commonFaceIndex[1];
+    owner_[commonFaceIndex[1]] = c1;
+    neighbour_[commonFaceIndex[1]] = -1;
+
+    // Second boundary face - Owner c[0], Neighbour -1
+    newBdyFace[2][0] = otherPointIndex[3];
+    newBdyFace[2][1] = nextToOtherPoint[3];
+    newBdyFace[2][2] = otherPointIndex[2];
+    newCell[0][c0count++] = commonFaceIndex[2];
+    owner_[commonFaceIndex[2]] = c0;
+    neighbour_[commonFaceIndex[2]] = -1;
+
+    // Third boundary face - Owner c[1], Neighbour -1
+    newBdyFace[3][0] = otherPointIndex[2];
+    newBdyFace[3][1] = nextToOtherPoint[2];
+    newBdyFace[3][2] = otherPointIndex[3];
+    newCell[1][c1count++] = commonFaceIndex[3];
+    owner_[commonFaceIndex[3]] = c1;
+    neighbour_[commonFaceIndex[3]] = -1;
+
+    if (debug > 1)
+    {
+        Info << "New flipped face: " << newFace << endl;
+
+        if (debug > 2)
+        {
+            forAll(newBdyFace, faceI)
+            {
+                Info << "New boundary face[" << faceI << "]: "
+                     << commonFaceIndex[faceI]
+                     << ": " << newBdyFace[faceI] << endl;
+            }
+        }
+    }
+
+    // Check the orientation of the two quad faces, and modify as necessary
+    label newOwn=0, newNei=0;
+
+    // The quad face belonging to cell[1] now becomes a part of cell[0]
+    if (neighbour_[commonIntFaceIndex[1]] == -1)
+    {
+        // Boundary face
+        // Face doesn't need to be flipped, just update the owner
+        f          = commonIntFaces[1];
+        newOwn     = c0;
+        newNei     = -1;
+    }
+    else
+    if (owner_[commonIntFaceIndex[1]] == c1)
+    {
+        // This face is on the interior, check for previous owner
+        // Upper-triangular ordering has to be maintained, however...
+        if (c0 > neighbour_[commonIntFaceIndex[1]])
+        {
+            // Flip is necessary
+            f          = commonIntFaces[1].reverseFace();
+            newOwn     = neighbour_[commonIntFaceIndex[1]];
+            newNei     = c0;
+
+            setFlip(commonIntFaceIndex[1]);
+        }
+        else
+        {
+            // Flip isn't necessary, just change the owner
+            f          = commonIntFaces[1];
+            newOwn     = c0;
+            newNei     = neighbour_[commonIntFaceIndex[1]];
+        }
+    }
+    else
+    if (neighbour_[commonIntFaceIndex[1]] == c1)
+    {
+        // This face is on the interior, check for previous neighbour
+        // Upper-triangular ordering has to be maintained, however...
+        if (c0 < owner_[commonIntFaceIndex[1]])
+        {
+            // Flip is necessary
+            f          = commonIntFaces[1].reverseFace();
+            newOwn     = c0;
+            newNei     = owner_[commonIntFaceIndex[1]];
+
+            setFlip(commonIntFaceIndex[1]);
+        }
+        else
+        {
+            // Flip isn't necessary, just change the neighbour
+            f          = commonIntFaces[1];
+            newOwn     = owner_[commonIntFaceIndex[1]];
+            newNei     = c0;
+        }
+    }
+
+    faces_[commonIntFaceIndex[1]] = f;
+    newCell[0][c0count++] = commonIntFaceIndex[0];
+    newCell[0][c0count++] = commonIntFaceIndex[1];
+    owner_[commonIntFaceIndex[1]] = newOwn;
+    neighbour_[commonIntFaceIndex[1]] = newNei;
+
+    // The quad face belonging to cell[0] now becomes a part of cell[1]
+    if (neighbour_[commonIntFaceIndex[2]] == -1)
+    {
+        // Boundary face
+        // Face doesn't need to be flipped, just update the owner
+        f          = commonIntFaces[2];
+        newOwn     = c1;
+        newNei     = -1;
+    }
+    else
+    if (owner_[commonIntFaceIndex[2]] == c0)
+    {
+        // This face is on the interior, check for previous owner
+        // Upper-triangular ordering has to be maintained, however...
+        if (c1 > neighbour_[commonIntFaceIndex[2]])
+        {
+            // Flip is necessary
+            f          = commonIntFaces[2].reverseFace();
+            newOwn     = neighbour_[commonIntFaceIndex[2]];
+            newNei     = c1;
+
+            setFlip(commonIntFaceIndex[2]);
+        }
+        else
+        {
+            // Flip isn't necessary, just change the owner
+            f          = commonIntFaces[2];
+            newOwn     = c1;
+            newNei     = neighbour_[commonIntFaceIndex[2]];
+        }
+    }
+    else
+    if (neighbour_[commonIntFaceIndex[2]] == c0)
+    {
+        // This face is on the interior, check for previous neighbour
+        // Upper-triangular ordering has to be maintained, however...
+        if (c1 < owner_[commonIntFaceIndex[2]])
+        {
+            // Flip is necessary
+            f          = commonIntFaces[2].reverseFace();
+            newOwn     = c1;
+            newNei     = owner_[commonIntFaceIndex[2]];
+
+            setFlip(commonIntFaceIndex[2]);
+        }
+        else
+        {
+            // Flip isn't necessary, just change the neighbour
+            f          = commonIntFaces[2];
+            newOwn     = owner_[commonIntFaceIndex[2]];
+            newNei     = c1;
+        }
+    }
+
+    faces_[commonIntFaceIndex[2]] = f;
+    newCell[1][c1count++] = commonIntFaceIndex[2];
+    newCell[1][c1count++] = commonIntFaceIndex[3];
+    owner_[commonIntFaceIndex[2]] = newOwn;
+    neighbour_[commonIntFaceIndex[2]] = newNei;
+
+    // Now that all entities are properly configured,
+    // overwrite the entries in connectivity lists.
+    cells_[c0] = newCell[0];
+    cells_[c1] = newCell[1];
+
+    faces_[fIndex] = newFace;
+    faceEdges_[fIndex] = newFEdges;
+
+    forAll(newBdyFace, faceI)
+    {
+        faces_[commonFaceIndex[faceI]] = newBdyFace[faceI];
+    }
+
+    edges_[commonEdgeIndex[0]] = newEdges[0];
+    edges_[commonEdgeIndex[1]] = newEdges[1];
+
+    // Fill-in mapping information
+    labelList mC(2, -1);
+    mC[0] = c0; mC[1] = c1;
+
+    forAll(mC, cellI)
+    {
+        // Set the mapping for this cell
+        setCellMapping(mC[cellI], mC);
+    }
+
+    // Interpolate new fluxes for the flipped face.
+    setFaceMapping(fIndex);
+
+    // Write out VTK files after change
+    if (debug > 3)
+    {
+        labelList cellHull(2, -1);
+
+        cellHull[0] = c0;
+        cellHull[1] = c1;
+
+        writeVTK
+        (
+            Foam::name(fIndex)
+          + "_Swap_1",
+            cellHull
+        );
+    }
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Increment the counter
+    statistics_[1]++;
+
+    // Return a successful operation.
+    map.type() = 1;
+
+    return map;
+}
+
+
+// Method for the swapping of an edge in 3D
+//  - To be used mainly for testing purposes only.
+//  - Use swap3DEdges on the entire mesh for efficiency.
+void dynamicTopoFvMesh::swapEdge
+(
+    const label eIndex,
+    bool forceOp
+)
+{
+    // Dynamic programming variables
+    labelList m;
+    PtrList<scalarListList> Q;
+    PtrList<labelListList> K, triangulations;
+
+    // Allocate dynamic programming tables
+    initTables(m, Q, K, triangulations);
+
+    // Compute the minimum quality of cells around this edge
+    scalar minQuality = computeMinQuality(eIndex);
+
+    // Check if this edge is on a bounding curve
+    if (checkBoundingCurve(eIndex))
+    {
+        FatalErrorIn
+        (
+            "void dynamicTopoFvMesh::swapEdge"
+            "(const label eIndex, bool forceOp)"
+        )
+            << nl << " Cannot swap edges on bounding curves. "
+            << abort(FatalError);
+    }
+
+    // Fill the dynamic programming tables
+    if (fillTables(eIndex, minQuality, m, Q, K, triangulations))
+    {
+        // Check if edge-swapping is required.
+        scalar newQuality = Q[0][0][m[0]-1];
+
+        if (newQuality > minQuality)
+        {
+            // Remove this edge according to the swap sequence
+            removeEdgeFlips(eIndex, minQuality, K, triangulations);
+        }
+        else
+        if (forceOp)
+        {
+            if (newQuality < 0.0)
+            {
+                FatalErrorIn
+                (
+                    "void dynamicTopoFvMesh::swapEdge"
+                    "(const label eIndex, bool forceOp)"
+                )
+                    << " Forcing swap on edge: " << eIndex
+                    << ":: " << edges_[eIndex]
+                    << " will yield an invalid cell quality: "
+                    << newQuality << " Old Quality: " << minQuality
+                    << abort(FatalError);
+            }
+            else
+            {
+                removeEdgeFlips(eIndex, minQuality, K, triangulations);
+            }
+        }
+    }
+}
+
+
+// Allocate dynamic programming tables
+void dynamicTopoFvMesh::initTables
+(
+    labelList& m,
+    PtrList<scalarListList>& Q,
+    PtrList<labelListList>& K,
+    PtrList<labelListList>& triangulations,
+    const label checkIndex
+) const
+{
+    label mMax = maxTetsPerEdge_;
+
+    // Check if resizing is necessary only for a particular index.
+    if (checkIndex != -1)
+    {
+        m[checkIndex] = -1;
+        Q[checkIndex].setSize((mMax-2),scalarList(mMax,-1.0));
+        K[checkIndex].setSize((mMax-2),labelList(mMax,-1));
+        triangulations[checkIndex].setSize(3,labelList((mMax-2),-1));
+
+        return;
+    }
+
+    // Size all elements by default.
+    label numIndices = -1;
+
+    {
+        numIndices = 1;
+    }
+
+    m.setSize(numIndices, -1);
+    Q.setSize(numIndices);
+    K.setSize(numIndices);
+    triangulations.setSize(numIndices);
+
+    forAll(Q, indexI)
+    {
+        Q.set
+        (
+            indexI,
+            new scalarListList((mMax-2),scalarList(mMax,-1.0))
+        );
+
+        K.set
+        (
+            indexI,
+            new labelListList((mMax-2),labelList(mMax,-1))
+        );
+
+        triangulations.set
+        (
+            indexI,
+            new labelListList(3,labelList((mMax-2),-1))
+        );
+    }
+}
+
+
+// Utility method to fill the dynamic programming tables
+//  - Returns true if the operation completed successfully.
+//  - Returns false if tables could not be resized.
+bool dynamicTopoFvMesh::fillTables
+(
+    const label eIndex,
+    const scalar minQuality,
+    labelList& m,
+    PtrList<scalarListList>& Q,
+    PtrList<labelListList>& K,
+    PtrList<labelListList>& triangulations,
+    const label checkIndex
+) const
+{
+    const edge& edgeToCheck = edges_[eIndex];
+    const labelList& hullVertices = edgePoints_[eIndex];
+
+    // Fill in the size
+    m[checkIndex] = hullVertices.size();
+
+    // Check if a table-resize is necessary
+    if (m[checkIndex] > maxTetsPerEdge_)
+    {
+        if (allowTableResize_)
+        {
+            // Resize the tables to account for
+            // more tets per edge
+            label& mtpe = const_cast<label&>(maxTetsPerEdge_);
+
+            mtpe = m[checkIndex];
+
+            // Clear tables for this index.
+            Q[checkIndex].clear();
+            K[checkIndex].clear();
+            triangulations[checkIndex].clear();
+
+            // Resize for this index.
+            initTables(m, Q, K, triangulations, checkIndex);
+        }
+        else
+        {
+            // Can't resize. Bail out.
+            return false;
+        }
+    }
+
+    for (label i = (m[checkIndex]-3); i >= 0; i--)
+    {
+        for (label j = i+2; j < m[checkIndex]; j++)
+        {
+            for (label k = i+1; k < j; k++)
+            {
+                scalar q = (*tetMetric_)
+                (
+                    points_[hullVertices[i]],
+                    points_[hullVertices[k]],
+                    points_[hullVertices[j]],
+                    points_[edgeToCheck[0]]
+                );
+
+                // For efficiency, check the bottom triangulation
+                // only when the top one if less than the hull quality.
+                if (q > minQuality)
+                {
+                    q =
+                    (
+                        Foam::min
+                        (
+                            q,
+                            (*tetMetric_)
+                            (
+                                points_[hullVertices[j]],
+                                points_[hullVertices[k]],
+                                points_[hullVertices[i]],
+                                points_[edgeToCheck[1]]
+                            )
+                        )
+                    );
+                }
+
+                if (k < j-1)
+                {
+                    q = Foam::min(q,Q[checkIndex][k][j]);
+                }
+
+                if (k > i+1)
+                {
+                    q = Foam::min(q,Q[checkIndex][i][k]);
+                }
+
+                if ((k == i+1) || (q > Q[checkIndex][i][j]))
+                {
+                    Q[checkIndex][i][j] = q;
+                    K[checkIndex][i][j] = k;
+                }
+            }
+        }
+    }
+
+    // Print out tables for debugging
+    if (debug > 3)
+    {
+        printTables(m, Q, K, checkIndex);
+    }
+
+    return true;
+}
+
+
+// Remove the edge according to the swap sequence.
+// - Returns a changeMap with a type specifying:
+//     1: Swap sequence was successful
+//    -1: Swap sequence failed
+const changeMap dynamicTopoFvMesh::removeEdgeFlips
+(
+    const label eIndex,
+    const scalar minQuality,
+    const PtrList<labelListList>& K,
+    PtrList<labelListList>& triangulations,
+    const label checkIndex
+)
+{
+    changeMap map, slaveMap;
+
+    if (debug > 2)
+    {
+        Info << " Removing edge : " << eIndex << " by flipping."
+             << " Edge: " << edges_[eIndex]
+             << " minQuality: " << minQuality << endl;
+    }
+
+    // Make a copy of edgePoints, since it will be
+    // modified during swaps
+    labelList hullVertices(edgePoints_[eIndex]);
+
+    label m = hullVertices.size();
+
+    labelList hullFaces(m, -1);
+    labelList hullCells(m, -1);
+    labelList hullEdges(m, -1);
+    labelListList ringEntities(4, labelList(m, -1));
+
+    // Construct the hull
+    meshOps::constructHull
+    (
+        eIndex,
+        faces_,
+        edges_,
+        cells_,
+        owner_,
+        neighbour_,
+        faceEdges_,
+        edgeFaces_,
+        edgePoints_,
+        hullEdges,
+        hullFaces,
+        hullCells,
+        ringEntities
+    );
+
+    label numTriangulations = 0, isolatedVertex = -1;
+
+    // Extract the appropriate triangulations
+    extractTriangulation
+    (
+        0,
+        m-1,
+        K[checkIndex],
+        numTriangulations,
+        triangulations[checkIndex]
+    );
+
+    // Check old-volumes for the configuration.
+    if
+    (
+        checkTriangulationVolumes
+        (
+            eIndex,
+            hullVertices,
+            triangulations[checkIndex]
+        )
+    )
+    {
+        // Reset all triangulations and bail out
+        triangulations[checkIndex][0] = -1;
+        triangulations[checkIndex][1] = -1;
+        triangulations[checkIndex][2] = -1;
+
+        return map;
+    }
+
+    // Determine the final swap triangulation
+    label tF =
+    (
+        identify32Swap
+        (
+            eIndex,
+            hullVertices,
+            triangulations[checkIndex]
+        )
+    );
+
+    // Check that the triangulation is valid
+
+    if (tF == -1)
+    {
+        const edge& edgeToCheck = edges_[eIndex];
+
+        Info << " All triangulations: " << nl
+             << ' ' << triangulations[checkIndex][0] << nl
+             << ' ' << triangulations[checkIndex][1] << nl
+             << ' ' << triangulations[checkIndex][2] << nl
+             << endl;
+
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    const scalar minQuality,\n"
+            "    const PtrList<labelListList>& K,\n"
+            "    PtrList<labelListList>& triangulations,\n"
+            "    const label checkIndex\n"
+            ")\n"
+        )
+            << "Could not determine 3-2 swap triangulation." << nl
+            << "Edge: " << edgeToCheck << nl
+            << "Edge Points: "
+            << points_[edgeToCheck[0]] << ","
+            << points_[edgeToCheck[1]] << nl
+            << abort(FatalError);
+
+        // Reset all triangulations and bail out
+        triangulations[checkIndex][0] = -1;
+        triangulations[checkIndex][1] = -1;
+        triangulations[checkIndex][2] = -1;
+
+        return map;
+    }
+
+    if (debug > 2)
+    {
+        Info << " Identified tF as: " << tF << endl;
+        Info << " Triangulation: "
+             << triangulations[checkIndex][0][tF] << " "
+             << triangulations[checkIndex][1][tF] << " "
+             << triangulations[checkIndex][2][tF] << " "
+             << endl;
+        Info << " All triangulations: " << nl
+             << ' ' << triangulations[checkIndex][0] << nl
+             << ' ' << triangulations[checkIndex][1] << nl
+             << ' ' << triangulations[checkIndex][2] << nl
+             << endl;
+    }
+
+    // Perform a series of 2-3 swaps
+    label numSwaps = 0;
+
+    while (numSwaps < (m-3))
+    {
+        for (label i = 0; i < (m-2); i++)
+        {
+            if ( (i != tF) && (triangulations[checkIndex][0][i] != -1) )
+            {
+                // Check if triangulation is on the boundary
+                if
+                (
+                    boundaryTriangulation
+                    (
+                        i,
+                        isolatedVertex,
+                        triangulations[checkIndex]
+                    )
+                )
+                {
+                    // Perform 2-3 swap
+                    map =
+                    (
+                        swap23
+                        (
+                            isolatedVertex,
+                            eIndex,
+                            i,
+                            numTriangulations,
+                            triangulations[checkIndex],
+                            hullVertices,
+                            hullFaces,
+                            hullCells
+                        )
+                    );
+
+                    // Done with this face, so reset it
+                    triangulations[checkIndex][0][i] = -1;
+                    triangulations[checkIndex][1][i] = -1;
+                    triangulations[checkIndex][2][i] = -1;
+
+                    numSwaps++;
+                }
+            }
+        }
+
+        if (numSwaps == 0)
+        {
+            Info << "Triangulations: " << endl;
+            forAll(triangulations[checkIndex], row)
+            {
+                Info << triangulations[checkIndex][row] << endl;
+            }
+
+            // Should have performed at least one swap
+            FatalErrorIn
+            (
+                "\n"
+                "const changeMap dynamicTopoFvMesh::removeEdgeFlips\n"
+                "(\n"
+                "    const label eIndex,\n"
+                "    const scalar minQuality,\n"
+                "    const PtrList<labelListList>& K,\n"
+                "    PtrList<labelListList>& triangulations,\n"
+                "    const label checkIndex\n"
+                ")\n"
+            )
+                << "Did not perform any 2-3 swaps" << nl
+                << abort(FatalError);
+        }
+    }
+
+    // Perform the final 3-2 / 2-2 swap
+    map =
+    (
+        swap32
+        (
+            eIndex,
+            tF,
+            numTriangulations,
+            triangulations[checkIndex],
+            hullVertices,
+            hullFaces,
+            hullCells
+        )
+    );
+
+    // Done with this face, so reset it
+    triangulations[checkIndex][0][tF] = -1;
+    triangulations[checkIndex][1][tF] = -1;
+    triangulations[checkIndex][2][tF] = -1;
+
+    // Finally remove the edge
+    removeEdge(eIndex);
+
+    // Increment the counter
+    statistics_[1]++;
+
+    // Set the flag
+    topoChangeFlag_ = true;
+
+    // Return a successful operation.
+    return map;
+}
+
+
+// Extract triangulations from the programming table
+void dynamicTopoFvMesh::extractTriangulation
+(
+    const label i,
+    const label j,
+    const labelListList& K,
+    label& numTriangulations,
+    labelListList& triangulations
+) const
+{
+    if ( j >= (i+2) )
+    {
+        label k = K[i][j];
+
+        // Fill in the triangulation list
+        triangulations[0][numTriangulations] = i;
+        triangulations[1][numTriangulations] = k;
+        triangulations[2][numTriangulations] = j;
+
+        // Increment triangulation count
+        numTriangulations++;
+
+        // Recursively call the function for the two sub-triangulations
+        extractTriangulation(i,k,K,numTriangulations,triangulations);
+        extractTriangulation(k,j,K,numTriangulations,triangulations);
+    }
+}
+
+
+// Identify the 3-2 swap from the triangulation sequence
+//  - Use an edge-plane intersection formula
+label dynamicTopoFvMesh::identify32Swap
+(
+    const label eIndex,
+    const labelList& hullVertices,
+    const labelListList& triangulations
+) const
+{
+    label m = hullVertices.size();
+    const edge& edgeToCheck = edges_[eIndex];
+
+    // Obtain intersection point.
+    linePointRef segment
+    (
+        points_[edgeToCheck.start()],
+        points_[edgeToCheck.end()]
+    );
+
+    vector intPt = vector::zero;
+
+    // Configure a face with triangulation
+    for (label i = 0; i < (m-2); i++)
+    {
+        bool intersects =
+        (
+            meshOps::segmentTriFaceIntersection
+            (
+                triPointRef
+                (
+                    points_[hullVertices[triangulations[0][i]]],
+                    points_[hullVertices[triangulations[1][i]]],
+                    points_[hullVertices[triangulations[2][i]]]
+                ),
+                segment,
+                1e-6,
+                intPt
+            )
+        );
+
+        if (intersects)
+        {
+            return i;
+        }
+    }
+
+    if (debug > 1)
+    {
+        Info << nl << nl << "Hull Vertices: " << endl;
+
+        forAll(hullVertices, vertexI)
+        {
+            Info << hullVertices[vertexI] << ": "
+                 << points_[hullVertices[vertexI]]
+                 << endl;
+        }
+
+        InfoIn
+        (
+            "\n"
+            "label dynamicTopoFvMesh::identify32Swap\n"
+            "(\n"
+            "    const label eIndex,\n"
+            "    const labelList& hullVertices,\n"
+            "    const labelListList& triangulations\n"
+            ") const\n"
+        )   << nl
+            << "Could not determine 3-2 swap triangulation." << nl
+            << "Edge: " << edgeToCheck << nl
+            << "Edge Points: "
+            << segment.start() << ","
+            << segment.end() << nl
+            << endl;
+    }
+
+    // Could not find an intersecting triangulation.
+    //  - If this is a boundary edge, a curved surface-mesh.
+    //    was probably the reason why this failed.
+    //  - If so, declare the nearest triangulation instead.
+    //  - Internal edges also occasionally encounter
+    //    precision issues. Use the same approach.
+    vector eCentre = segment.centre();
+
+    scalarField dist(m-2, 0.0);
+
+    label mT = -1, ePatch = whichEdgePatch(eIndex);
+    bool foundTriangulation = false;
+
+    for (label i = 0; i < (m-2); i++)
+    {
+        // Compute edge to face-centre distance.
+        dist[i] =
+        (
+            mag
+            (
+                eCentre
+              - triPointRef
+                (
+                    points_[hullVertices[triangulations[0][i]]],
+                    points_[hullVertices[triangulations[1][i]]],
+                    points_[hullVertices[triangulations[2][i]]]
+                ).centre()
+            )
+        );
+    }
+
+    while (!foundTriangulation)
+    {
+        mT = findMin(dist);
+
+        // Check validity for boundary edges
+        if
+        (
+            (ePatch > -1) &&
+            ((triangulations[0][mT] != 0) || (triangulations[2][mT] != m-1))
+        )
+        {
+            // This is a 2-3 triangulation. Try again.
+            dist[mT] = GREAT;
+        }
+        else
+        {
+            foundTriangulation = true;
+        }
+    }
+
+    if (debug > 1)
+    {
+        Info << " All distances :" << dist << nl
+             << " Triangulation index: " << mT
+             << endl;
+    }
+
+    // Return the index
+    return mT;
+}
+
+
+// Routine to check whether the triangulation at the
+// index lies on the boundary of the vertex ring.
+bool dynamicTopoFvMesh::boundaryTriangulation
+(
+    const label index,
+    label& isolatedVertex,
+    labelListList& triangulations
+) const
+{
+    label first = 0, second = 0, third = 0;
+
+    // Count for occurrences
+    forAll(triangulations, row)
+    {
+        forAll(triangulations[row], col)
+        {
+            if (triangulations[row][col] == triangulations[0][index])
+            {
+                first++;
+            }
+
+            if (triangulations[row][col] == triangulations[1][index])
+            {
+                second++;
+            }
+
+            if (triangulations[row][col] == triangulations[2][index])
+            {
+                third++;
+            }
+        }
+    }
+
+    if (first == 1)
+    {
+        isolatedVertex = triangulations[0][index];
+        return true;
+    }
+
+    if (second == 1)
+    {
+        isolatedVertex = triangulations[1][index];
+        return true;
+    }
+
+    if (third == 1)
+    {
+        isolatedVertex = triangulations[2][index];
+        return true;
+    }
+
+    // This isn't a boundary triangulation
+    return false;
+}
+
+
+// Utility method to compute the minimum quality of a vertex hull
+scalar dynamicTopoFvMesh::computeMinQuality
+(
+    const label eIndex
+) const
+{
+    scalar minQuality = GREAT;
+    scalar cQuality = 0.0;
+
+    // Obtain a reference to this edge and corresponding edgePoints
+    const edge& edgeToCheck = edges_[eIndex];
+    const labelList& hullVertices = edgePoints_[eIndex];
+
+    // Obtain point references
+    const point& a = points_[edgeToCheck[0]];
+    const point& c = points_[edgeToCheck[1]];
+
+    if (whichEdgePatch(eIndex) < 0)
+    {
+        // Internal edge.
+        forAll(hullVertices, indexI)
+        {
+            label prevIndex = hullVertices.rcIndex(indexI);
+
+            // Pick vertices off the list
+            const point& b = points_[hullVertices[prevIndex]];
+            const point& d = points_[hullVertices[indexI]];
+
+            // Compute the quality
+            cQuality = tetMetric_(a, b, c, d);
+
+            // Check if the quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+        }
+    }
+    else
+    {
+        // Boundary edge.
+        for(label indexI = 1; indexI < hullVertices.size(); indexI++)
+        {
+            // Pick vertices off the list
+            const point& b = points_[hullVertices[indexI-1]];
+            const point& d = points_[hullVertices[indexI]];
+
+            // Compute the quality
+            cQuality = tetMetric_(a, b, c, d);
+
+            // Check if the quality is worse
+            minQuality = Foam::min(cQuality, minQuality);
+        }
+    }
+
+    // Ensure that the mesh is valid
+    if (minQuality < 0.0)
+    {
+        // if (debug > 3)
+        {
+            // Write out faces and cells for post processing.
+            labelHashSet iFaces, iCells, bFaces;
+
+            const labelList& eFaces = edgeFaces_[eIndex];
+
+            forAll(eFaces, faceI)
+            {
+                iFaces.insert(eFaces[faceI]);
+
+                if (!iCells.found(owner_[eFaces[faceI]]))
+                {
+                    iCells.insert(owner_[eFaces[faceI]]);
+                }
+
+                if (!iCells.found(neighbour_[eFaces[faceI]]))
+                {
+                    iCells.insert(neighbour_[eFaces[faceI]]);
+                }
+            }
+
+            writeVTK(Foam::name(eIndex) + "_iCells", iCells.toc());
+            writeVTK(Foam::name(eIndex) + "_iFaces", iFaces.toc(), 2);
+
+            // Write out the boundary patches (for post-processing reference)
+            for
+            (
+                label faceI = nOldInternalFaces_;
+                faceI < faces_.size();
+                faceI++
+            )
+            {
+                if (faces_[faceI].empty())
+                {
+                    continue;
+                }
+
+                label pIndex = whichPatch(faceI);
+
+                if (pIndex != -1)
+                {
+                    bFaces.insert(faceI);
+                }
+            }
+
+            writeVTK(Foam::name(eIndex) + "_bFaces", bFaces.toc(), 2);
+        }
+
+        FatalErrorIn
+        (
+            "scalar dynamicTopoFvMesh::computeMinQuality"
+            "(const label eIndex) const"
+        )
+            << "Encountered negative cell-quality!" << nl
+            << "Edge: " << eIndex << ": " << edgeToCheck << nl
+            << "EdgePoints: " << hullVertices << nl
+            << "Minimum Quality: " << minQuality
+            << abort(FatalError);
+    }
+
+    return minQuality;
+}
+
+
+// Method used to perform a 2-3 swap in 3D
+// - Returns a changeMap with the index of
+//   the triangulated face in opposingFace.
+const changeMap dynamicTopoFvMesh::swap23
+(
+    const label isolatedVertex,
+    const label eIndex,
+    const label triangulationIndex,
+    const label numTriangulations,
+    const labelListList& triangulations,
+    const labelList& hullVertices,
+    const labelList& hullFaces,
+    const labelList& hullCells
+)
+{
+    // A 2-3 swap performs the following operations:
+    //      [1] Remove face: [ edge[0] edge[1] isolatedVertex ]
+    //      [2] Remove two cells on either side of removed face
+    //      [3] Add one edge
+    //      [4] Add three new faces
+    //      [5] Add three new cells
+    //      Update faceEdges, edgeFaces and edgePoints information
+
+    changeMap map;
+
+    // Obtain a copy of the edge
+    edge edgeToCheck = edges_[eIndex];
+
+    label faceForRemoval = hullFaces[isolatedVertex];
+    label vertexForRemoval = hullVertices[isolatedVertex];
+
+    // Determine the two cells to be removed
+    FixedList<label,2> cellsForRemoval;
+    cellsForRemoval[0] = owner_[faceForRemoval];
+    cellsForRemoval[1] = neighbour_[faceForRemoval];
+
+    if (debug > 1)
+    {
+        // Print out arguments
+        Info << endl;
+        Info << "== Swapping 2-3 ==" << endl;
+        Info << "Edge: " << eIndex << ": " << edgeToCheck << endl;
+
+        if (debug > 2)
+        {
+            label bPatch = whichEdgePatch(eIndex);
+
+            if (bPatch == -1)
+            {
+                Info << "Patch: Internal" << endl;
+            }
+            else
+            {
+                Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+            }
+
+            Info << "Ring: " << hullVertices << endl;
+            Info << "Faces: " << hullFaces << endl;
+            Info << "Cells: " << hullCells << endl;
+            Info << "Triangulation: "
+                 << triangulations[0][triangulationIndex] << " "
+                 << triangulations[1][triangulationIndex] << " "
+                 << triangulations[2][triangulationIndex] << " "
+                 << endl;
+            Info << "Isolated vertex: " << isolatedVertex << endl;
+        }
+
+        if (debug > 3)
+        {
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + '(' + Foam::name(edgeToCheck[0])
+              + ',' + Foam::name(edgeToCheck[1]) + ')'
+              + "_beforeSwap_"
+              + Foam::name(numTriangulations) + "_"
+              + Foam::name(triangulationIndex),
+                cellsForRemoval
+            );
+        }
+    }
+
+    // Check if this is an internal face
+    if (cellsForRemoval[1] == -1)
+    {
+        // Write out for post-processing
+        writeVTK("Edge23_" + Foam::name(eIndex), eIndex, 1);
+        writeVTK("Cells23_" + Foam::name(eIndex), hullCells, 3);
+
+        FatalErrorIn
+        (
+            "\n"
+            "const changeMap dynamicTopoFvMesh::swap23\n"
+            "(\n"
+            "    const label isolatedVertex,\n"
+            "    const label eIndex,\n"
+            "    const label triangulationIndex,\n"
+            "    const label numTriangulations,\n"
+            "    const labelListList& triangulations,\n"
+            "    const labelList& hullVertices,\n"
+            "    const labelList& hullFaces,\n"
+            "    const labelList& hullCells\n"
+            ")\n"
+        )
+            << " Expected an internal face,"
+            << " but found a boundary one instead." << nl
+            << " Looks like identify32Swap couldn't correctly identify"
+            << " the 2-2 swap triangulation." << nl
+            << abort(FatalError);
+    }
+
+    // Add three new cells to the end of the cell list
+    FixedList<label,3> newCellIndex(-1);
+    FixedList<cell, 3> newTetCell(cell(4));
+
+    forAll(newCellIndex, cellI)
+    {
+        scalar avgScale = -1.0;
+
+        if (edgeRefinement_)
+        {
+            avgScale =
+            (
+                0.5 *
+                (
+                    lengthScale_[cellsForRemoval[0]]
+                  + lengthScale_[cellsForRemoval[1]]
+                )
+            );
+        }
+
+        // Insert the cell
+        newCellIndex[cellI] = insertCell(newTetCell[cellI], avgScale);
+    }
+
+    // Obtain point-ordering for the other vertices
+    // otherVertices[0] is the point before isolatedVertex
+    // otherVertices[1] is the point after isolatedVertex
+    FixedList<label,2> otherVertices;
+
+    if (triangulations[0][triangulationIndex] == isolatedVertex)
+    {
+        otherVertices[0] = hullVertices[triangulations[2][triangulationIndex]];
+        otherVertices[1] = hullVertices[triangulations[1][triangulationIndex]];
+    }
+    else
+    if (triangulations[1][triangulationIndex] == isolatedVertex)
+    {
+        otherVertices[0] = hullVertices[triangulations[0][triangulationIndex]];
+        otherVertices[1] = hullVertices[triangulations[2][triangulationIndex]];
+    }
+    else
+    {
+        otherVertices[0] = hullVertices[triangulations[1][triangulationIndex]];
+        otherVertices[1] = hullVertices[triangulations[0][triangulationIndex]];
+    }
+
+    // Insert three new internal faces
+    FixedList<label,3> newFaceIndex;
+    face tmpTriFace(3);
+
+    // First face: The actual triangulation
+    tmpTriFace[0] = otherVertices[0];
+    tmpTriFace[1] = vertexForRemoval;
+    tmpTriFace[2] = otherVertices[1];
+
+    newFaceIndex[0] =
+    (
+        insertFace
+        (
+            -1,
+            tmpTriFace,
+            newCellIndex[0],
+            newCellIndex[1]
+        )
+    );
+
+    // Add an entry to the map
+    map.opposingFace() = newFaceIndex[0];
+
+    // Second face: Triangle involving edgeToCheck[0]
+    tmpTriFace[0] = otherVertices[0];
+    tmpTriFace[1] = edgeToCheck[0];
+    tmpTriFace[2] = otherVertices[1];
+
+    newFaceIndex[1] =
+    (
+        insertFace
+        (
+            -1,
+            tmpTriFace,
+            newCellIndex[1],
+            newCellIndex[2]
+        )
+    );
+
+    // Third face: Triangle involving edgeToCheck[1]
+    tmpTriFace[0] = otherVertices[1];
+    tmpTriFace[1] = edgeToCheck[1];
+    tmpTriFace[2] = otherVertices[0];
+
+    newFaceIndex[2] =
+    (
+        insertFace
+        (
+            -1,
+            tmpTriFace,
+            newCellIndex[0],
+            newCellIndex[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];
+    newEdgeFaces[1] = newFaceIndex[1];
+    newEdgeFaces[2] = newFaceIndex[2];
+
+    // Add an entry for edgePoints as well
+    labelList newEdgePoints(3);
+    newEdgePoints[0] = vertexForRemoval;
+    newEdgePoints[1] = edgeToCheck[0];
+    newEdgePoints[2] = edgeToCheck[1];
+
+    // Add a new internal edge to the mesh
+    label newEdgeIndex =
+    (
+        insertEdge
+        (
+            -1,
+            edge
+            (
+                otherVertices[0],
+                otherVertices[1]
+            ),
+            newEdgeFaces,
+            newEdgePoints
+        )
+    );
+
+    // Define the six edges to check while building faceEdges:
+    FixedList<edge,6> check;
+
+    check[0][0] = vertexForRemoval; check[0][1] = otherVertices[0];
+    check[1][0] = vertexForRemoval; check[1][1] = otherVertices[1];
+    check[2][0] = edgeToCheck[0];   check[2][1] = otherVertices[0];
+    check[3][0] = edgeToCheck[1];   check[3][1] = otherVertices[0];
+    check[4][0] = edgeToCheck[0];   check[4][1] = otherVertices[1];
+    check[5][0] = edgeToCheck[1];   check[5][1] = otherVertices[1];
+
+    // Add three new entries to faceEdges
+    label nE0 = 0, nE1 = 0, nE2 = 0;
+    FixedList<labelList,3> newFaceEdges(labelList(3));
+
+    newFaceEdges[0][nE0++] = newEdgeIndex;
+    newFaceEdges[1][nE1++] = newEdgeIndex;
+    newFaceEdges[2][nE2++] = newEdgeIndex;
+
+    // Fill-in information for the three new cells,
+    // and correct info on existing neighbouring cells
+    label nF0 = 0, nF1 = 0, nF2 = 0;
+    FixedList<bool,2> foundEdge;
+
+    // Add the newly created faces to cells
+    newTetCell[0][nF0++] = newFaceIndex[0];
+    newTetCell[0][nF0++] = newFaceIndex[2];
+    newTetCell[1][nF1++] = newFaceIndex[0];
+    newTetCell[1][nF1++] = newFaceIndex[1];
+    newTetCell[2][nF2++] = newFaceIndex[1];
+    newTetCell[2][nF2++] = newFaceIndex[2];
+
+    forAll(cellsForRemoval, cellI)
+    {
+        label cellIndex = cellsForRemoval[cellI];
+
+        forAll(cells_[cellIndex], faceI)
+        {
+            label faceIndex = cells_[cellIndex][faceI];
+
+            foundEdge[0] = false; foundEdge[1] = false;
+
+            // Check if face contains edgeToCheck[0]
+            if
+            (
+                (faces_[faceIndex][0] == edgeToCheck[0])
+             || (faces_[faceIndex][1] == edgeToCheck[0])
+             || (faces_[faceIndex][2] == edgeToCheck[0])
+            )
+            {
+                foundEdge[0] = true;
+            }
+
+            // Check if face contains edgeToCheck[1]
+            if
+            (
+                (faces_[faceIndex][0] == edgeToCheck[1])
+             || (faces_[faceIndex][1] == edgeToCheck[1])
+             || (faces_[faceIndex][2] == edgeToCheck[1])
+            )
+            {
+                foundEdge[1] = true;
+            }
+
+            // Face is connected to edgeToCheck[0]
+            if (foundEdge[0] && !foundEdge[1])
+            {
+                // Check if a face-flip is necessary
+                if (owner_[faceIndex] == cellIndex)
+                {
+                    if (neighbour_[faceIndex] == -1)
+                    {
+                        // Change the owner
+                        owner_[faceIndex] = newCellIndex[1];
+                    }
+                    else
+                    {
+                        // Flip this face
+                        faces_[faceIndex] = faces_[faceIndex].reverseFace();
+                        owner_[faceIndex] = neighbour_[faceIndex];
+                        neighbour_[faceIndex] = newCellIndex[1];
+
+                        setFlip(faceIndex);
+                    }
+                }
+                else
+                {
+                    // Flip is unnecessary. Just update neighbour
+                    neighbour_[faceIndex] = newCellIndex[1];
+                }
+
+                // Add this face to the cell
+                newTetCell[1][nF1++] = faceIndex;
+
+                // Update faceEdges, edgeFaces, and edgePoints.
+                forAll(faceEdges_[faceIndex], edgeI)
+                {
+                    if (edges_[faceEdges_[faceIndex][edgeI]] == check[0])
+                    {
+                        newFaceEdges[0][nE0++] = faceEdges_[faceIndex][edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[0],
+                            edgeFaces_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[1],
+                            edgeToCheck[0],
+                            edgeToCheck[1],
+                            edgePoints_[faceEdges_[faceIndex][edgeI]]
+                        );
+                    }
+
+                    if (edges_[faceEdges_[faceIndex][edgeI]] == check[1])
+                    {
+                        newFaceEdges[0][nE0++] = faceEdges_[faceIndex][edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[0],
+                            edgeFaces_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[0],
+                            edgeToCheck[0],
+                            edgeToCheck[1],
+                            edgePoints_[faceEdges_[faceIndex][edgeI]]
+                        );
+                    }
+
+                    if (edges_[faceEdges_[faceIndex][edgeI]] == check[2])
+                    {
+                        newFaceEdges[1][nE1++] = faceEdges_[faceIndex][edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[1],
+                            edgeFaces_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[1],
+                            vertexForRemoval,
+                            edgeToCheck[1],
+                            edgePoints_[faceEdges_[faceIndex][edgeI]]
+                        );
+                    }
+
+                    if (edges_[faceEdges_[faceIndex][edgeI]] == check[4])
+                    {
+                        newFaceEdges[1][nE1++] = faceEdges_[faceIndex][edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[1],
+                            edgeFaces_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[0],
+                            vertexForRemoval,
+                            edgeToCheck[1],
+                            edgePoints_[faceEdges_[faceIndex][edgeI]]
+                        );
+                    }
+                }
+            }
+
+            // Face is connected to edgeToCheck[1]
+            if (!foundEdge[0] && foundEdge[1])
+            {
+                // Check if a face-flip is necessary
+                if (owner_[faceIndex] == cellIndex)
+                {
+                    if (neighbour_[faceIndex] == -1)
+                    {
+                        // Change the owner
+                        owner_[faceIndex] = newCellIndex[0];
+                    }
+                    else
+                    {
+                        // Flip this face
+                        faces_[faceIndex] = faces_[faceIndex].reverseFace();
+                        owner_[faceIndex] = neighbour_[faceIndex];
+                        neighbour_[faceIndex] = newCellIndex[0];
+
+                        setFlip(faceIndex);
+                    }
+                }
+                else
+                {
+                    // Flip is unnecessary. Just update neighbour
+                    neighbour_[faceIndex] = newCellIndex[0];
+                }
+
+                // Add this face to the cell
+                newTetCell[0][nF0++] = faceIndex;
+
+                // Update faceEdges, edgeFaces, and edgePoints.
+                const labelList& fEdges = faceEdges_[faceIndex];
+
+                forAll(fEdges, edgeI)
+                {
+                    if (edges_[fEdges[edgeI]] == check[3])
+                    {
+                        newFaceEdges[2][nE2++] = fEdges[edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[2],
+                            edgeFaces_[fEdges[edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[1],
+                            vertexForRemoval,
+                            edgeToCheck[0],
+                            edgePoints_[fEdges[edgeI]]
+                        );
+                    }
+
+                    if (edges_[fEdges[edgeI]] == check[5])
+                    {
+                        newFaceEdges[2][nE2++] = fEdges[edgeI];
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex[2],
+                            edgeFaces_[fEdges[edgeI]]
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherVertices[0],
+                            vertexForRemoval,
+                            edgeToCheck[0],
+                            edgePoints_[fEdges[edgeI]]
+                        );
+                    }
+                }
+            }
+
+            // Face is connected to both edgeToCheck [0] and [1]
+            if
+            (
+                (foundEdge[0] && foundEdge[1]) &&
+                (faceIndex != faceForRemoval)
+            )
+            {
+                // Check if a face-flip is necessary
+                if (owner_[faceIndex] == cellIndex)
+                {
+                    if (neighbour_[faceIndex] == -1)
+                    {
+                        // Change the owner
+                        owner_[faceIndex] = newCellIndex[2];
+                    }
+                    else
+                    {
+                        // Flip this face
+                        faces_[faceIndex] = faces_[faceIndex].reverseFace();
+                        owner_[faceIndex] = neighbour_[faceIndex];
+                        neighbour_[faceIndex] = newCellIndex[2];
+
+                        setFlip(faceIndex);
+                    }
+                }
+                else
+                {
+                    // Flip is unnecessary. Just update neighbour
+                    neighbour_[faceIndex] = newCellIndex[2];
+                }
+
+                // Add this face to the cell
+                newTetCell[2][nF2++] = faceIndex;
+            }
+        }
+    }
+
+    // Now update faceEdges for the three new faces
+    forAll(newFaceEdges, faceI)
+    {
+        faceEdges_[newFaceIndex[faceI]] = newFaceEdges[faceI];
+    }
+
+    // Update edgeFaces and edgePoints for edges of the removed face
+    label otherPoint = -1, nextPoint = -1;
+
+    forAll(faceEdges_[faceForRemoval], edgeI)
+    {
+        label edgeIndex = faceEdges_[faceForRemoval][edgeI];
+
+        meshOps::sizeDownList
+        (
+            faceForRemoval,
+            edgeFaces_[edgeIndex]
+        );
+
+        // Find the isolated point and remove it
+        meshOps::findIsolatedPoint
+        (
+            faces_[faceForRemoval],
+            edges_[edgeIndex],
+            otherPoint,
+            nextPoint
+        );
+
+        meshOps::sizeDownList
+        (
+            otherPoint,
+            edgePoints_[edgeIndex]
+        );
+    }
+
+    // Remove the face
+    removeFace(faceForRemoval);
+
+    forAll(cellsForRemoval, cellI)
+    {
+        removeCell(cellsForRemoval[cellI]);
+    }
+
+    // Fill-in candidate mapping information
+    labelList mC(2, -1);
+
+    forAll(mC, indexI)
+    {
+        mC[indexI] = cellsForRemoval[indexI];
+    }
+
+    // Update the cell list with newly configured cells.
+    forAll(newCellIndex, cellI)
+    {
+        cells_[newCellIndex[cellI]] = newTetCell[cellI];
+
+        if (cellI == 2)
+        {
+            // Skip mapping for the intermediate cell.
+            setCellMapping(newCellIndex[cellI], mC, false);
+        }
+        else
+        {
+            // Set the mapping for this cell
+            setCellMapping(newCellIndex[cellI], mC);
+        }
+    }
+
+    // Fill in mapping information for three new faces.
+    // Since they're all internal, interpolate fluxes by default.
+    forAll(newFaceIndex, faceI)
+    {
+        setFaceMapping(newFaceIndex[faceI]);
+    }
+
+    if (debug > 2)
+    {
+        Info << "Added edge: " << endl;
+
+        Info << newEdgeIndex << ":: "
+             << edges_[newEdgeIndex]
+             << " edgeFaces: "
+             << edgeFaces_[newEdgeIndex]
+             << endl;
+
+        Info << "Added faces: " << endl;
+
+        forAll(newFaceIndex, faceI)
+        {
+            Info << newFaceIndex[faceI] << ":: "
+                 << faces_[newFaceIndex[faceI]]
+                 << " faceEdges: "
+                 << faceEdges_[newFaceIndex[faceI]]
+                 << endl;
+        }
+
+        Info << "Added cells: " << endl;
+
+        forAll(newCellIndex, cellI)
+        {
+            Info << newCellIndex[cellI] << ":: "
+                 << cells_[newCellIndex[cellI]]
+                 << endl;
+        }
+
+        if (debug > 3)
+        {
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + '(' + Foam::name(edgeToCheck[0])
+              + ',' + Foam::name(edgeToCheck[1]) + ')'
+              + "_afterSwap_"
+              + Foam::name(numTriangulations) + "_"
+              + Foam::name(triangulationIndex),
+                newCellIndex
+            );
+        }
+    }
+
+    // Specify that the swap was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+
+// Method used to perform a 2-2 / 3-2 swap in 3D
+// - Returns a changeMap with a type specifying:
+//     1: Swap was successful
+// - The index of the triangulated face in opposingFace.
+// - For 2-2 swaps, the newly added edge index.
+const changeMap dynamicTopoFvMesh::swap32
+(
+    const label eIndex,
+    const label triangulationIndex,
+    const label numTriangulations,
+    const labelListList& triangulations,
+    const labelList& hullVertices,
+    const labelList& hullFaces,
+    const labelList& hullCells
+)
+{
+    // A 2-2 / 3-2 swap performs the following operations:
+    //      [1] Remove three faces surrounding edgeToCheck
+    //      [2] Remove two (2-2 swap) or three(3-2 swap)
+    //          cells surrounding edgeToCheck
+    //      [3] Add one internal face
+    //      [4] Add two new cells
+    //      [5] If edgeToCheck is on a boundary,
+    //          add two boundary faces and a boundary edge (2-2 swap)
+    //      eIndex is removed later by removeEdgeFlips
+    //      Update faceEdges, edgeFaces and edgePoints information
+
+    changeMap map;
+
+    // Obtain a copy of the edge
+    edge edgeToCheck = edges_[eIndex];
+
+    // Determine the patch this edge belongs to
+    label edgePatch = whichEdgePatch(eIndex);
+
+    // Determine the three faces to be removed
+    FixedList<label,3> facesForRemoval;
+    labelHashSet cellsForRemoval(3);
+
+    forAll(facesForRemoval, faceI)
+    {
+        facesForRemoval[faceI] =
+        (
+            hullFaces[triangulations[faceI][triangulationIndex]]
+        );
+
+        label own = owner_[facesForRemoval[faceI]];
+        label nei = neighbour_[facesForRemoval[faceI]];
+
+        // Check and add cells as well
+        if (!cellsForRemoval.found(own))
+        {
+            cellsForRemoval.insert(own);
+        }
+
+        if (!cellsForRemoval.found(nei) && nei != -1)
+        {
+            cellsForRemoval.insert(nei);
+        }
+    }
+
+    labelList cellRemovalList = cellsForRemoval.toc();
+
+    if (debug > 1)
+    {
+        // Print out arguments
+        Info << endl;
+
+        if (edgePatch < 0)
+        {
+            Info << "== Swapping 3-2 ==" << endl;
+        }
+        else
+        {
+            Info << "== Swapping 2-2 ==" << endl;
+        }
+
+        Info << "Edge: " << eIndex << ": " << edgeToCheck << endl;
+
+        if (debug > 2)
+        {
+            label bPatch = whichEdgePatch(eIndex);
+
+            if (bPatch == -1)
+            {
+                Info << "Patch: Internal" << endl;
+            }
+            else
+            {
+                Info << "Patch: " << boundaryMesh()[bPatch].name() << endl;
+            }
+
+            Info << "Ring: " << hullVertices << endl;
+            Info << "Faces: " << hullFaces << endl;
+            Info << "Cells: " << hullCells << endl;
+            Info << "Triangulation: "
+                 << triangulations[0][triangulationIndex] << " "
+                 << triangulations[1][triangulationIndex] << " "
+                 << triangulations[2][triangulationIndex] << " "
+                 << endl;
+        }
+
+        if (debug > 3)
+        {
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + '(' + Foam::name(edgeToCheck[0])
+              + ',' + Foam::name(edgeToCheck[1]) + ')'
+              + "_beforeSwap_"
+              + Foam::name(numTriangulations) + "_"
+              + Foam::name(triangulationIndex),
+                cellRemovalList
+            );
+        }
+    }
+
+    // Add two new cells to the end of the cell list
+    FixedList<label,2> newCellIndex(-1);
+    FixedList<cell, 2> newTetCell(cell(4));
+
+    forAll(newCellIndex, cellI)
+    {
+        scalar avgScale = 0.0;
+
+        if (edgeRefinement_)
+        {
+            forAll(cellRemovalList, indexI)
+            {
+                avgScale += lengthScale_[cellRemovalList[indexI]];
+            }
+
+            avgScale /= cellRemovalList.size();
+        }
+
+        // Insert the cell
+        newCellIndex[cellI] = insertCell(newTetCell[cellI], avgScale);
+    }
+
+    // Insert a new internal face
+    face newTriFace(3);
+
+    newTriFace[0] = hullVertices[triangulations[0][triangulationIndex]];
+    newTriFace[1] = hullVertices[triangulations[1][triangulationIndex]];
+    newTriFace[2] = hullVertices[triangulations[2][triangulationIndex]];
+
+    label newFaceIndex =
+    (
+        insertFace
+        (
+            -1,
+            newTriFace,
+            newCellIndex[0],
+            newCellIndex[1]
+        )
+    );
+
+    // Add an entry to the map
+    map.opposingFace() = 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;
+
+    check[0][0] = newTriFace[0]; check[0][1] = newTriFace[1];
+    check[1][0] = newTriFace[1]; check[1][1] = newTriFace[2];
+    check[2][0] = newTriFace[2]; check[2][1] = newTriFace[0];
+
+    // For 2-2 swaps, two faces are introduced
+    label nE = 0, nBf = 0;
+    FixedList<label,2> nBE(0);
+    FixedList<labelList,2> bdyFaceEdges(labelList(3, -1));
+
+    // Fill-in information for the two new cells,
+    // and correct info on existing neighbouring cells
+    label nF0 = 0, nF1 = 0;
+    label otherPoint = -1, nextPoint = -1;
+    FixedList<bool,2> foundEdge;
+
+    // For a 2-2 swap on a boundary edge,
+    // add two boundary faces and an edge
+    label newEdgeIndex = -1;
+    labelList oldBdyFaceIndex(2, -1), newBdyFaceIndex(2, -1);
+
+    if (edgePatch > -1)
+    {
+        // Temporary local variables
+        label facePatch = -1;
+        edge newEdge(-1, -1);
+        FixedList<label,2> nBEdge(0);
+        FixedList<FixedList<label,2>,2> bdyEdges;
+        FixedList<face,2> newBdyTriFace(face(3));
+
+        // Get a cue for face orientation from existing faces
+        forAll(facesForRemoval, faceI)
+        {
+            if (neighbour_[facesForRemoval[faceI]] == -1)
+            {
+                facePatch = whichPatch(facesForRemoval[faceI]);
+
+                // Record this face-index for mapping.
+                oldBdyFaceIndex[nBf++] = facesForRemoval[faceI];
+
+                meshOps::findIsolatedPoint
+                (
+                    faces_[facesForRemoval[faceI]],
+                    edgeToCheck,
+                    otherPoint,
+                    nextPoint
+                );
+
+                if (nextPoint == edgeToCheck[0])
+                {
+                    newEdge[1] = otherPoint;
+                    newBdyTriFace[0][0] = otherPoint;
+                    newBdyTriFace[0][1] = edgeToCheck[0];
+                    newBdyTriFace[1][2] = otherPoint;
+                }
+                else
+                {
+                    newEdge[0] = otherPoint;
+                    newBdyTriFace[1][0] = otherPoint;
+                    newBdyTriFace[1][1] = edgeToCheck[1];
+                    newBdyTriFace[0][2] = otherPoint;
+                }
+
+                // Also update faceEdges for the new boundary faces
+                forAll(faceEdges_[facesForRemoval[faceI]], edgeI)
+                {
+                    if
+                    (
+                        edges_[faceEdges_[facesForRemoval[faceI]][edgeI]]
+                     == edge(edgeToCheck[0], otherPoint)
+                    )
+                    {
+                        bdyFaceEdges[0][nBE[0]++] =
+                        (
+                            faceEdges_[facesForRemoval[faceI]][edgeI]
+                        );
+
+                        bdyEdges[0][nBEdge[0]++] =
+                        (
+                            faceEdges_[facesForRemoval[faceI]][edgeI]
+                        );
+                    }
+
+                    if
+                    (
+                        edges_[faceEdges_[facesForRemoval[faceI]][edgeI]]
+                     == edge(edgeToCheck[1], otherPoint)
+                    )
+                    {
+                        bdyFaceEdges[1][nBE[1]++] =
+                        (
+                            faceEdges_[facesForRemoval[faceI]][edgeI]
+                        );
+
+                        bdyEdges[1][nBEdge[1]++] =
+                        (
+                            faceEdges_[facesForRemoval[faceI]][edgeI]
+                        );
+                    }
+                }
+            }
+        }
+
+        // Insert the first of two new faces
+        newBdyFaceIndex[0] =
+        (
+            insertFace
+            (
+                facePatch,
+                newBdyTriFace[0],
+                newCellIndex[1],
+                -1
+            )
+        );
+
+        // Add this face to the map.
+        map.addFace(newBdyFaceIndex[0]);
+
+        // Insert the second of two new faces
+        newBdyFaceIndex[1] =
+        (
+            insertFace
+            (
+                facePatch,
+                newBdyTriFace[1],
+                newCellIndex[0],
+                -1
+            )
+        );
+
+        // Add this face to the map.
+        map.addFace(newBdyFaceIndex[1]);
+
+        // Update the new cells
+        newTetCell[0][nF0++] = newBdyFaceIndex[1];
+        newTetCell[1][nF1++] = newBdyFaceIndex[0];
+
+        // Add an edgeFaces entry
+        labelList newBdyEdgeFaces(3, -1);
+        newBdyEdgeFaces[0] = newBdyFaceIndex[0];
+        newBdyEdgeFaces[1] = newFaceIndex;
+        newBdyEdgeFaces[2] = newBdyFaceIndex[1];
+
+        // Find the point other than the new edge
+        // on the new triangular face
+        meshOps::findIsolatedPoint
+        (
+            newTriFace,
+            newEdge,
+            otherPoint,
+            nextPoint
+        );
+
+        // Add an edgePoints entry
+        labelList newBdyEdgePoints(3, -1);
+        newBdyEdgePoints[0] = edgeToCheck[0];
+        newBdyEdgePoints[1] = otherPoint;
+        newBdyEdgePoints[2] = edgeToCheck[1];
+
+        // Insert the edge
+        newEdgeIndex =
+        (
+            insertEdge
+            (
+                edgePatch,
+                newEdge,
+                newBdyEdgeFaces,
+                newBdyEdgePoints
+            )
+        );
+
+        // Add this edge to the map.
+        map.addEdge(newEdgeIndex);
+
+        // Update faceEdges with the new edge
+        faceEdges_[newFaceIndex][nE++] = newEdgeIndex;
+        bdyFaceEdges[0][nBE[0]++] = newEdgeIndex;
+        bdyFaceEdges[1][nBE[1]++] = newEdgeIndex;
+
+        // Update edgeFaces and edgePoints with the two new faces
+        forAll(bdyEdges[0], edgeI)
+        {
+            meshOps::sizeUpList
+            (
+                newBdyFaceIndex[0],
+                edgeFaces_[bdyEdges[0][edgeI]]
+            );
+
+            meshOps::sizeUpList
+            (
+                newBdyFaceIndex[1],
+                edgeFaces_[bdyEdges[1][edgeI]]
+            );
+
+            // Replace the edgePoints label, and preserve position on the list
+            meshOps::findIsolatedPoint
+            (
+                newBdyTriFace[0],
+                edges_[bdyEdges[0][edgeI]],
+                otherPoint,
+                nextPoint
+            );
+
+            meshOps::replaceLabel
+            (
+                edgeToCheck[1],
+                otherPoint,
+                edgePoints_[bdyEdges[0][edgeI]]
+            );
+
+            // Size up edgePoints again, so that it is sized down later
+            meshOps::sizeUpList
+            (
+                edgeToCheck[1],
+                edgePoints_[bdyEdges[0][edgeI]]
+            );
+
+            // Replace the edgePoints label, and preserve position on the list
+            meshOps::findIsolatedPoint
+            (
+                newBdyTriFace[1],
+                edges_[bdyEdges[1][edgeI]],
+                otherPoint,
+                nextPoint
+            );
+
+            meshOps::replaceLabel
+            (
+                edgeToCheck[0],
+                otherPoint,
+                edgePoints_[bdyEdges[1][edgeI]]
+            );
+
+            // Size up edgePoints again, so that it is sized down later
+            meshOps::sizeUpList
+            (
+                edgeToCheck[0],
+                edgePoints_[bdyEdges[1][edgeI]]
+            );
+        }
+
+        // Add faceEdges for the two new boundary faces
+        faceEdges_.append(bdyFaceEdges[0]);
+        faceEdges_.append(bdyFaceEdges[1]);
+
+        // Update the number of surface swaps.
+        statistics_[2]++;
+    }
+
+    newTetCell[0][nF0++] = newFaceIndex;
+    newTetCell[1][nF1++] = newFaceIndex;
+
+    forAll(cellRemovalList, cellI)
+    {
+        label cellIndex = cellRemovalList[cellI];
+
+        forAll(cells_[cellIndex], faceI)
+        {
+            label faceIndex = cells_[cellIndex][faceI];
+
+            foundEdge[0] = false; foundEdge[1] = false;
+
+            // Find the face that contains only
+            // edgeToCheck[0] or edgeToCheck[1]
+            forAll(faces_[faceIndex], pointI)
+            {
+                if (faces_[faceIndex][pointI] == edgeToCheck[0])
+                {
+                    foundEdge[0] = true;
+                }
+
+                if (faces_[faceIndex][pointI] == edgeToCheck[1])
+                {
+                    foundEdge[1] = true;
+                }
+            }
+
+            // Face is connected to edgeToCheck[0]
+            if (foundEdge[0] && !foundEdge[1])
+            {
+                // Check if a face-flip is necessary
+                if (owner_[faceIndex] == cellIndex)
+                {
+                    if (neighbour_[faceIndex] == -1)
+                    {
+                        // Change the owner
+                        owner_[faceIndex] = newCellIndex[1];
+                    }
+                    else
+                    {
+                        // Flip this face
+                        faces_[faceIndex] = faces_[faceIndex].reverseFace();
+                        owner_[faceIndex] = neighbour_[faceIndex];
+                        neighbour_[faceIndex] = newCellIndex[1];
+
+                        setFlip(faceIndex);
+                    }
+                }
+                else
+                {
+                    // Flip is unnecessary. Just update neighbour
+                    neighbour_[faceIndex] = newCellIndex[1];
+                }
+
+                // Add this face to the cell
+                newTetCell[1][nF1++] = faceIndex;
+
+                // Update faceEdges, edgeFaces and edgePoints
+                forAll(faceEdges_[faceIndex], edgeI)
+                {
+                    if
+                    (
+                        (edges_[faceEdges_[faceIndex][edgeI]] == check[0])
+                     || (edges_[faceEdges_[faceIndex][edgeI]] == check[1])
+                     || (edges_[faceEdges_[faceIndex][edgeI]] == check[2])
+                    )
+                    {
+                        faceEdges_[newFaceIndex][nE++] =
+                        (
+                            faceEdges_[faceIndex][edgeI]
+                        );
+
+                        meshOps::sizeUpList
+                        (
+                            newFaceIndex,
+                            edgeFaces_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        // Find the isolated point and insert it
+                        meshOps::findIsolatedPoint
+                        (
+                            newTriFace,
+                            edges_[faceEdges_[faceIndex][edgeI]],
+                            otherPoint,
+                            nextPoint
+                        );
+
+                        meshOps::insertLabel
+                        (
+                            otherPoint,
+                            edgeToCheck[0],
+                            edgeToCheck[1],
+                            edgePoints_[faceEdges_[faceIndex][edgeI]]
+                        );
+
+                        break;
+                    }
+                }
+            }
+
+            // Face is connected to edgeToCheck[1]
+            if (!foundEdge[0] && foundEdge[1])
+            {
+                // Check if a face-flip is necessary
+                if (owner_[faceIndex] == cellIndex)
+                {
+                    if (neighbour_[faceIndex] == -1)
+                    {
+                        // Change the owner
+                        owner_[faceIndex] = newCellIndex[0];
+                    }
+                    else
+                    {
+                        // Flip this face
+                        faces_[faceIndex] = faces_[faceIndex].reverseFace();
+                        owner_[faceIndex] = neighbour_[faceIndex];
+                        neighbour_[faceIndex] = newCellIndex[0];
+
+                        setFlip(faceIndex);
+                    }
+                }
+                else
+                {
+                    // Flip is unnecessary. Just update neighbour
+                    neighbour_[faceIndex] = newCellIndex[0];
+                }
+
+                // Add this face to the cell
+                newTetCell[0][nF0++] = faceIndex;
+            }
+        }
+    }
+
+    // Remove the faces and update associated edges
+    forAll(facesForRemoval, faceI)
+    {
+        // Update edgeFaces and edgePoints
+        forAll(faceEdges_[facesForRemoval[faceI]], edgeI)
+        {
+            label edgeIndex = faceEdges_[facesForRemoval[faceI]][edgeI];
+
+            if (edgeIndex != eIndex)
+            {
+                meshOps::sizeDownList
+                (
+                    facesForRemoval[faceI],
+                    edgeFaces_[edgeIndex]
+                );
+
+                // Find the isolated point and remove it
+                meshOps::findIsolatedPoint
+                (
+                    faces_[facesForRemoval[faceI]],
+                    edges_[edgeIndex],
+                    otherPoint,
+                    nextPoint
+                );
+
+                meshOps::sizeDownList
+                (
+                    otherPoint,
+                    edgePoints_[edgeIndex]
+                );
+            }
+        }
+
+        // Now remove the face...
+        removeFace(facesForRemoval[faceI]);
+    }
+
+    forAll(cellRemovalList, cellI)
+    {
+        removeCell(cellRemovalList[cellI]);
+    }
+
+    // Update the cell list with newly configured cells.
+    forAll(newCellIndex, cellI)
+    {
+        cells_[newCellIndex[cellI]] = newTetCell[cellI];
+
+        // Fill-in candidate mapping information
+        labelList mC(cellRemovalList.size(), -1);
+
+        forAll(mC, indexI)
+        {
+            mC[indexI] = cellRemovalList[indexI];
+        }
+
+        // Set the mapping for this cell
+        setCellMapping(newCellIndex[cellI], mC);
+    }
+
+    // Set fill-in mapping for two new boundary faces
+    if (edgePatch > -1)
+    {
+        forAll(newBdyFaceIndex, i)
+        {
+            // Set the mapping for this face
+            setFaceMapping(newBdyFaceIndex[i], oldBdyFaceIndex);
+        }
+    }
+
+    // Fill in mapping information for the new face.
+    // Since it is internal, interpolate fluxes by default.
+    setFaceMapping(newFaceIndex);
+
+    if (debug > 2)
+    {
+        if (edgePatch > -1)
+        {
+            Info << "Added edge: " << endl;
+
+            Info << newEdgeIndex << ":: "
+                 << edges_[newEdgeIndex]
+                 << " edgeFaces: "
+                 << edgeFaces_[newEdgeIndex]
+                 << endl;
+        }
+
+        Info << "Added face(s): " << endl;
+
+        Info << newFaceIndex << ":: "
+             << faces_[newFaceIndex];
+
+        Info << " faceEdges: "
+             << faceEdges_[newFaceIndex]
+             << endl;
+
+        if (edgePatch > -1)
+        {
+            forAll(newBdyFaceIndex, faceI)
+            {
+                Info << newBdyFaceIndex[faceI] << ":: "
+                     << faces_[newBdyFaceIndex[faceI]]
+                     << " faceEdges: "
+                     << faceEdges_[newBdyFaceIndex[faceI]]
+                     << endl;
+            }
+        }
+
+        Info << "Added cells: " << endl;
+
+        forAll(newCellIndex, cellI)
+        {
+            Info << newCellIndex[cellI] << ":: "
+                 << cells_[newCellIndex[cellI]]
+                 << endl;
+        }
+
+        if (debug > 3)
+        {
+            writeVTK
+            (
+                Foam::name(eIndex)
+              + '(' + Foam::name(edgeToCheck[0])
+              + ',' + Foam::name(edgeToCheck[1]) + ')'
+              + "_afterSwap_"
+              + Foam::name(numTriangulations) + "_"
+              + Foam::name(triangulationIndex),
+                newCellIndex
+            );
+        }
+    }
+
+    // Specify that the swap was successful
+    map.type() = 1;
+
+    // Return the changeMap
+    return map;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
new file mode 100644
index 000000000..e7c0dba9f
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.C
@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    fluxCorrector
+
+Description
+    Implementation of the fluxCorrector base class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "fluxCorrector.H"
+#include "dlLibraryTable.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(fluxCorrector, 0);
+defineRunTimeSelectionTable(fluxCorrector, mesh);
+
+// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
+
+autoPtr<fluxCorrector> fluxCorrector::New
+(
+    const fvMesh& mesh,
+    const dictionary& dict
+)
+{
+    // Check if an optional entry was specified
+    if (dict.found("fluxCorrector"))
+    {
+        word correctorTypeName(dict.lookup("fluxCorrector"));
+
+        // Open any supplied libraries in dictionary
+        dlLibraryTable::open
+        (
+            dict,
+            "fluxCorrectorLibs",
+            meshConstructorTablePtr_
+        );
+
+        if (!meshConstructorTablePtr_)
+        {
+            FatalErrorIn
+            (
+                "autoPtr<fluxCorrector> fluxCorrector::New"
+                "(const fvMesh& mesh, const dictionary& dict)"
+            )   << "fluxCorrector table is empty"
+                << exit(FatalError);
+        }
+
+        correctorTypeName = word(dict.lookup("fluxCorrector"));
+
+        meshConstructorTable::iterator cstrIter =
+            meshConstructorTablePtr_->find(correctorTypeName);
+
+        if (cstrIter == meshConstructorTablePtr_->end())
+        {
+            FatalErrorIn
+            (
+                "autoPtr<fluxCorrector> fluxCorrector::New"
+                "(const fvMesh& mesh, const dictionary& dict)"
+            )   << "Unknown fluxCorrector type " << correctorTypeName
+                << endl << endl
+                << "Valid fluxCorrector types are: " << endl
+                << meshConstructorTablePtr_->toc()
+                << exit(FatalError);
+        }
+
+        return autoPtr<fluxCorrector>(cstrIter()(mesh, dict));
+    }
+
+    // Return the default fluxCorrector
+    return autoPtr<fluxCorrector>(new fluxCorrector(mesh, dict));
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Return reference to mesh
+const fvMesh& fluxCorrector::mesh() const
+{
+    return mesh_;
+}
+
+
+//- Return reference to dictionary
+const dictionary& fluxCorrector::dict() const
+{
+    return dict_;
+}
+
+
+//- Is flux-correction required?
+bool fluxCorrector::required() const
+{
+    // Support for cases which do not involve a flow-solver.
+    // Notify the user, just in case.
+    Info << " ~~~ No flux correction ~~~ " << endl;
+
+    return false;
+}
+
+
+//- Interpolate fluxes to a specified list of faces
+void fluxCorrector::interpolateFluxes(const labelList& faces) const
+{
+    if (required())
+    {
+        // Throw an error stating that the scheme hasn't been implemented
+        notImplemented
+        (
+            "void fluxCorrector::interpolateFluxes"
+            "(const labelList& faces) const"
+        );
+    }
+}
+
+
+//- Update fluxes in the registry, if required
+void fluxCorrector::updateFluxes() const
+{
+    if (required())
+    {
+        // Throw an error stating that the scheme hasn't been implemented
+        notImplemented("void fluxCorrector::updateFluxes() const");
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+void fluxCorrector::operator=(const fluxCorrector& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn("fluxCorrector::operator=(const fluxCorrector&)")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H
new file mode 100644
index 000000000..f80ca0cc2
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/fluxCorrector.H
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    fluxCorrector
+
+Description
+    Virtual base class that deals with flux-correction after topo-changes.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    fluxCorrector.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fluxCorrector_H
+#define fluxCorrector_H
+
+#include "fvMesh.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward class declarations
+
+/*---------------------------------------------------------------------------*\
+                         Class fluxCorrector Declaration
+\*---------------------------------------------------------------------------*/
+
+class fluxCorrector
+{
+    // Private data
+
+        //- Reference to fvMesh
+        const fvMesh& mesh_;
+
+        //- Reference to dictionary
+        const dictionary& dict_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        fluxCorrector(const fluxCorrector&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fluxCorrector&);
+
+public:
+
+    //- Runtime type information
+    TypeName("fluxCorrector");
+
+
+    // Declare run-time constructor selection tables
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            fluxCorrector,
+            mesh,
+            (
+                const fvMesh& mesh,
+                const dictionary& dict
+            ),
+            (mesh, dict)
+        );
+
+
+    // Selectors
+
+        //- Select constructed from fvMesh
+        static autoPtr<fluxCorrector> New
+        (
+            const fvMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    // Constructors
+
+        //- Construct from fvMesh and dictionary
+        fluxCorrector(const fvMesh& mesh, const dictionary& dict)
+        :
+            mesh_(mesh),
+            dict_(dict)
+        {}
+
+
+    // Destructor
+
+        virtual ~fluxCorrector()
+        {}
+
+
+    // Member Functions
+
+        //- Return reference to mesh
+        const fvMesh& mesh() const;
+
+        //- Return reference to dictionary
+        const dictionary& dict() const;
+
+        //- Is flux-correction required?
+        virtual bool required() const;
+
+        //- Interpolate fluxes to a specified list of faces
+        virtual void interpolateFluxes(const labelList& faces) const;
+
+        //- Update fluxes in the registry
+        virtual void updateFluxes() const;
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#ifdef NoRepository
+#include "fluxCorrector.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoBoundaryMeshMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoBoundaryMeshMapper.H
new file mode 100644
index 000000000..50ad4492a
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoBoundaryMeshMapper.H
@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoBoundaryMeshMapper
+
+Description
+    This object provides mapping and fill-in information for boundary data
+    between the two meshes after the topological change.  It is
+    constructed from mapPolyMesh.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef topoBoundaryMeshMapper_H
+#define topoBoundaryMeshMapper_H
+
+#include "PtrList.H"
+#include "topoPatchMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class topoBoundaryMeshMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class topoBoundaryMeshMapper
+:
+    public PtrList<topoPatchMapper>
+{
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        topoBoundaryMeshMapper(const topoBoundaryMeshMapper&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const topoBoundaryMeshMapper&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        topoBoundaryMeshMapper
+        (
+            const fvMesh& mesh,
+            const mapPolyMesh& mpm,
+            const topoMapper& mapper
+        )
+        :
+            PtrList<topoPatchMapper>(mesh.boundary().size())
+        {
+            const fvBoundaryMesh& patches = mesh.boundary();
+
+            forAll (patches, patchI)
+            {
+                set
+                (
+                    patchI,
+                    new topoPatchMapper
+                    (
+                        patches[patchI],
+                        mpm,
+                        mapper
+                    )
+                );
+            }
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C
new file mode 100644
index 000000000..7535964b4
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.C
@@ -0,0 +1,570 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoCellMapper
+
+Description
+    Implementation of the topoCellMapper class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "IOmanip.H"
+#include "topoMapper.H"
+#include "mapPolyMesh.H"
+#include "topoCellMapper.H"
+#include "demandDrivenData.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+//- Clear out local storage
+void topoCellMapper::clearOut()
+{
+    deleteDemandDrivenData(directAddrPtr_);
+    deleteDemandDrivenData(interpolationAddrPtr_);
+    deleteDemandDrivenData(weightsPtr_);
+    deleteDemandDrivenData(insertedCellLabelsPtr_);
+    deleteDemandDrivenData(volumesPtr_);
+    deleteDemandDrivenData(centresPtr_);
+}
+
+
+//- Calculate addressing for interpolative mapping
+void topoCellMapper::calcAddressing() const
+{
+    if (directAddrPtr_ || interpolationAddrPtr_)
+    {
+        FatalErrorIn("void topoCellMapper::calcAddressing() const")
+            << "Addressing already calculated."
+            << abort(FatalError);
+    }
+
+    // Allocate for inserted cell labels
+    label nInsertedCells = 0;
+
+    insertedCellLabelsPtr_ = new labelList(mesh_.nCells(), -1);
+    labelList& insertedCells = *insertedCellLabelsPtr_;
+
+    if (direct())
+    {
+        // Direct addressing, no weights
+        directAddrPtr_ = new labelList(mpm_.cellMap());
+    }
+    else
+    {
+        // Interpolative addressing
+        interpolationAddrPtr_ = new labelListList(mesh_.nCells());
+        labelListList& addr = *interpolationAddrPtr_;
+
+        const List<objectMap>& cfc = mpm_.cellsFromCellsMap();
+
+        forAll (cfc, cfcI)
+        {
+            // Get addressing
+            const labelList& mo = cfc[cfcI].masterObjects();
+
+            label cellI = cfc[cfcI].index();
+
+            if (addr[cellI].size() > 0)
+            {
+                FatalErrorIn("void topoCellMapper::calcAddressing() const")
+                    << "Master cell " << cellI
+                    << " mapped from cells " << mo
+                    << " is already destination for mapping."
+                    << abort(FatalError);
+            }
+
+            // Set master objects
+            addr[cellI] = mo;
+        }
+
+        // Do mapped cells. Note that this can already be set by cellsFromCells
+        // so check if addressing size still zero.
+        const labelList& cm = mpm_.cellMap();
+
+        forAll (cm, cellI)
+        {
+            // Mapped from a single cell
+            if (cm[cellI] > -1 && addr[cellI].empty())
+            {
+                addr[cellI] = labelList(1, cm[cellI]);
+            }
+
+            // Check for inserted cells without any addressing
+            if (cm[cellI] < 0 && addr[cellI].empty())
+            {
+                insertedCells[nInsertedCells++] = cellI;
+            }
+        }
+    }
+
+    // Shorten inserted cells to actual size
+    insertedCells.setSize(nInsertedCells);
+
+    if (nInsertedCells)
+    {
+        FatalErrorIn("void topoCellMapper::calcAddressing() const")
+            << " Found " << nInsertedCells << " which are"
+            << " not mapped from any parent cells." << nl
+            << " List: " << nl
+            << insertedCells
+            << abort(FatalError);
+    }
+}
+
+
+//- Calculate inverse-distance weights for interpolative mapping
+void topoCellMapper::calcInverseDistanceWeights() const
+{
+    if (weightsPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoCellMapper::calcInverseDistanceWeights() const"
+        )
+            << "Weights already calculated."
+            << abort(FatalError);
+    }
+
+    // Fetch interpolative addressing
+    const labelListList& addr = addressing();
+
+    // Allocate memory
+    weightsPtr_ = new scalarListList(size());
+    scalarListList& w = *weightsPtr_;
+
+    // Obtain cell-centre information from old/new meshes
+    const vectorField& oldCentres = tMapper_.internalCentres();
+    const vectorField& newCentres = mesh_.cellCentres();
+
+    forAll(addr, cellI)
+    {
+        const labelList& mo = addr[cellI];
+
+        // Do mapped cells
+        if (mo.size() == 1)
+        {
+            w[cellI] = scalarList(1, 1.0);
+        }
+        else
+        {
+            // Map from masters, inverse-distance weights
+            scalar totalWeight = 0.0;
+            w[cellI] = scalarList(mo.size(), 0.0);
+
+            forAll (mo, oldCellI)
+            {
+                w[cellI][oldCellI] =
+                (
+                    1.0/stabilise
+                    (
+                        magSqr
+                        (
+                            newCentres[cellI]
+                          - oldCentres[mo[oldCellI]]
+                        ),
+                        VSMALL
+                    )
+                );
+
+                totalWeight += w[cellI][oldCellI];
+            }
+
+            // Normalize weights
+            scalar normFactor = (1.0/totalWeight);
+
+            forAll (mo, oldCellI)
+            {
+                w[cellI][oldCellI] *= normFactor;
+            }
+        }
+    }
+}
+
+
+//- Calculate intersection weights for conservative mapping
+void topoCellMapper::calcIntersectionWeightsAndCentres() const
+{
+    if (volumesPtr_ || centresPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoCellMapper::"
+            "calcIntersectionWeightsAndCentres() const"
+        )
+            << "Weights already calculated."
+            << abort(FatalError);
+    }
+
+    // Fetch interpolative addressing
+    const labelListList& addr = addressing();
+
+    // Allocate memory
+    volumesPtr_ = new List<scalarField>(size(), scalarField(0));
+    List<scalarField>& v = *volumesPtr_;
+
+    centresPtr_ = new List<vectorField>(size(), vectorField(0));
+    List<vectorField>& x = *centresPtr_;
+
+    // Obtain stored cell-centres
+    const vectorField& cellCentres = tMapper_.internalCentres();
+
+    // Fetch maps
+    const List<objectMap>& cfc = mpm_.cellsFromCellsMap();
+    const List<vectorField>& mapCellCentres = tMapper_.cellCentres();
+    const List<scalarField>& mapCellWeights = tMapper_.cellWeights();
+
+    // Fill in maps first
+    forAll(cfc, indexI)
+    {
+        x[cfc[indexI].index()] = mapCellCentres[indexI];
+        v[cfc[indexI].index()] = mapCellWeights[indexI];
+    }
+
+    // Now do mapped cells
+    forAll(addr, cellI)
+    {
+        const labelList& mo = addr[cellI];
+
+        // Check if this is indeed a mapped cell
+        if (mo.size() == 1 && x[cellI].empty() && v[cellI].empty())
+        {
+            x[cellI] = vectorField(1, cellCentres[mo[0]]);
+            v[cellI] = scalarField(1, 1.0);
+        }
+    }
+}
+
+
+const List<scalarField>& topoCellMapper::intersectionWeights() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const List<scalarField>& "
+            "topoCellMapper::intersectionWeights() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!volumesPtr_)
+    {
+        calcIntersectionWeightsAndCentres();
+    }
+
+    return *volumesPtr_;
+}
+
+
+const List<vectorField>& topoCellMapper::intersectionCentres() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const List<vectorField>& "
+            "topoCellMapper::intersectionCentres() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!centresPtr_)
+    {
+        calcIntersectionWeightsAndCentres();
+    }
+
+    return *centresPtr_;
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+topoCellMapper::topoCellMapper
+(
+    const mapPolyMesh& mpm,
+    const topoMapper& mapper
+)
+:
+    mesh_(mpm.mesh()),
+    mpm_(mpm),
+    tMapper_(mapper),
+    direct_(false),
+    directAddrPtr_(NULL),
+    interpolationAddrPtr_(NULL),
+    weightsPtr_(NULL),
+    insertedCellLabelsPtr_(NULL),
+    volumesPtr_(NULL),
+    centresPtr_(NULL)
+{
+    // Check for possibility of direct mapping
+    if
+    (
+        (min(mpm_.cellMap()) > -1)
+     && mpm_.cellsFromPointsMap().empty()
+     && mpm_.cellsFromEdgesMap().empty()
+     && mpm_.cellsFromFacesMap().empty()
+     && mpm_.cellsFromCellsMap().empty()
+    )
+    {
+        direct_ = true;
+    }
+    else
+    {
+        direct_ = false;
+    }
+}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+topoCellMapper::~topoCellMapper()
+{
+    clearOut();
+}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Return size
+label topoCellMapper::size() const
+{
+    return mesh_.nCells();
+}
+
+
+//- Return size before mapping
+label topoCellMapper::sizeBeforeMapping() const
+{
+    return mpm_.nOldCells();
+}
+
+
+//- Is the mapping direct
+bool topoCellMapper::direct() const
+{
+    return direct_;
+}
+
+
+//- Return direct addressing
+const unallocLabelList& topoCellMapper::directAddressing() const
+{
+    if (!direct())
+    {
+        FatalErrorIn
+        (
+            "const unallocLabelList& "
+            "topoCellMapper::directAddressing() const"
+        )   << "Requested direct addressing for an interpolative mapper."
+            << abort(FatalError);
+    }
+
+    if (!directAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *directAddrPtr_;
+}
+
+
+//- Return interpolation addressing
+const labelListList& topoCellMapper::addressing() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const labelListList& "
+            "topoCellMapper::addressing() const"
+        )   << "Requested interpolative addressing for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!interpolationAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *interpolationAddrPtr_;
+}
+
+
+//- Return weights
+const scalarListList& topoCellMapper::weights() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const scalarListList& "
+            "topoCellMapper::weights() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!weightsPtr_)
+    {
+        calcInverseDistanceWeights();
+    }
+
+    return *weightsPtr_;
+}
+
+
+//- Are there any inserted cells
+bool topoCellMapper::insertedObjects() const
+{
+    return insertedObjectLabels().size();
+}
+
+
+//- Return list of inserted cells
+const labelList& topoCellMapper::insertedObjectLabels() const
+{
+    if (!insertedCellLabelsPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *insertedCellLabelsPtr_;
+}
+
+
+//- Conservatively map the internal field
+template <class Type, class gradType>
+void topoCellMapper::mapInternalField
+(
+    const word& fieldName,
+    const Field<gradType>& gF,
+    Field<Type>& iF
+) const
+{
+    if (iF.size() != sizeBeforeMapping() || gF.size() != sizeBeforeMapping())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "void topoCellMapper::mapInternalField<Type>\n"
+            "(\n"
+            "    const word& fieldName,\n"
+            "    const Field<gradType>& gF,\n"
+            "    Field<Type>& iF\n"
+            ") const\n"
+        )  << "Incompatible size before mapping." << nl
+           << " Field: " << fieldName << nl
+           << " Field size: " << iF.size() << nl
+           << " Gradient Field size: " << gF.size() << nl
+           << " map size: " << sizeBeforeMapping() << nl
+           << abort(FatalError);
+    }
+
+    // Fetch addressing
+    const labelListList& cAddressing = addressing();
+    const List<scalarField>& wC = intersectionWeights();
+    const List<vectorField>& xC = intersectionCentres();
+
+    // Fetch geometry
+    const vectorField& centres = tMapper_.internalCentres();
+
+    // Compute the integral of the source field
+    Type intSource = sum(iF * tMapper_.cellVolumes());
+
+    // Copy the original field
+    Field<Type> fieldCpy(iF);
+
+    // Resize to current dimensions
+    iF.setSize(size());
+
+    // Map the internal field
+    forAll(iF, cellI)
+    {
+        const labelList& addr = cAddressing[cellI];
+
+        iF[cellI] = pTraits<Type>::zero;
+
+        forAll(addr, cellJ)
+        {
+            // Accumulate volume-weighted Taylor-series interpolate
+            iF[cellI] +=
+            (
+                wC[cellI][cellJ] *
+                (
+                    fieldCpy[addr[cellJ]]
+                  + (
+                        gF[addr[cellJ]] &
+                        (
+                            xC[cellI][cellJ]
+                          - centres[addr[cellJ]]
+                        )
+                    )
+                )
+            );
+        }
+    }
+
+    // Compute the integral of the target field
+    Type intTarget = sum(iF * mesh_.cellVolumes());
+
+    if (polyMesh::debug)
+    {
+        int oldP = Info().precision();
+
+        // Compare the global integral
+        Info << " Field : " << fieldName
+             << " integral errors : "
+             << setprecision(15)
+             << " source : " << mag(intSource)
+             << " target : " << mag(intTarget)
+             << " norm : "
+             << (mag(intTarget - intSource) / (mag(intSource) + VSMALL))
+             << setprecision(oldP)
+             << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void topoCellMapper::operator=(const topoCellMapper& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn("void topoCellMapper::operator=")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H
new file mode 100644
index 000000000..725937998
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoCellMapper.H
@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoCellMapper
+
+Description
+    This object provides mapping and fill-in information for internal
+    cell data between the two meshes after topological changes.
+    It is constructed from mapPolyMesh.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    topoCellMapper.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef topoCellMapper_H
+#define topoCellMapper_H
+
+#include "morphFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class topoMapper;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class topoCellMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class topoCellMapper
+:
+    public morphFieldMapper
+{
+    // Private data
+
+        //- Reference to polyMesh
+        const polyMesh& mesh_;
+
+        //- Reference to mapPolyMesh
+        const mapPolyMesh& mpm_;
+
+        //- Reference to the topoMapper
+        const topoMapper& tMapper_;
+
+        //- Is the mapping direct
+        bool direct_;
+
+    // Demand-driven private data
+
+        //- Direct addressing
+        mutable labelList* directAddrPtr_;
+
+        //- Interpolated addressing
+        mutable labelListList* interpolationAddrPtr_;
+
+        //- Inverse-distance weights
+        mutable scalarListList* weightsPtr_;
+
+        //- Inserted cells
+        mutable labelList* insertedCellLabelsPtr_;
+
+        //- Interpolation volumes
+        mutable List<scalarField>* volumesPtr_;
+
+        //- Interpolation centres
+        mutable List<vectorField>* centresPtr_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        topoCellMapper(const topoCellMapper&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const topoCellMapper&);
+
+        //- Calculate addressing for interpolative mapping
+        void calcAddressing() const;
+
+        //- Calculate inverse-distance weights for interpolative mapping
+        void calcInverseDistanceWeights() const;
+
+        //- Calculate intersection weights for conservative mapping
+        void calcIntersectionWeightsAndCentres() const;
+
+        //- Return intersection volume weights
+        const List<scalarField>& intersectionWeights() const;
+
+        //- Return intersection volume centres
+        const List<vectorField>& intersectionCentres() const;
+
+        //- Clear out local storage
+        void clearOut();
+
+public:
+
+    // Constructors
+
+        //- Construct from mapPolyMesh
+        topoCellMapper
+        (
+            const mapPolyMesh& mpm,
+            const topoMapper& mapper
+        );
+
+    // Destructor
+
+        virtual ~topoCellMapper();
+
+    // Member Functions
+
+        //- Return size
+        virtual label size() const;
+
+        //- Return size before mapping
+        virtual label sizeBeforeMapping() const;
+
+        //- Is the mapping direct
+        virtual bool direct() const;
+
+        //- Return direct addressing
+        virtual const unallocLabelList& directAddressing() const;
+
+        //- Return interpolation addressing
+        virtual const labelListList& addressing() const;
+
+        //- Return weights
+        virtual const scalarListList& weights() const;
+
+        //- Are there any inserted cells
+        virtual bool insertedObjects() const;
+
+        //- Return list of inserted cells
+        virtual const labelList& insertedObjectLabels() const;
+
+        //- Conservatively map the internal field
+        template <class Type, class gradType>
+        void mapInternalField
+        (
+            const word& fieldName,
+            const Field<gradType>& gF,
+            Field<Type>& iF
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#ifdef NoRepository
+#    include "topoCellMapper.C"
+#endif
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
new file mode 100644
index 000000000..3d69a78a1
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.C
@@ -0,0 +1,637 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoMapper
+
+Description
+    Implementation of topoMapper
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "fvc.H"
+#include "topoMapper.H"
+#include "fluxCorrector.H"
+#include "topoCellMapper.H"
+#include "leastSquaresGrad.H"
+#include "topoSurfaceMapper.H"
+#include "topoBoundaryMeshMapper.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Store gradients of fields on the mesh prior to topology changes
+template <class Type, class gradType>
+void topoMapper::storeGradients
+(
+    HashTable<autoPtr<gradType> >& gradTable
+) const
+{
+    // Define a few typedefs for convenience
+    typedef typename outerProduct<vector, Type>::type gCmptType;
+    typedef GeometricField<Type, fvPatchField, volMesh> volType;
+    typedef GeometricField<gCmptType, fvPatchField, volMesh> gVolType;
+
+    // Fetch all fields from registry
+    HashTable<const volType*> fields
+    (
+        mesh_.objectRegistry::lookupClass<volType>()
+    );
+
+    forAllConstIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        const volType& field = *fIter();
+
+        // Compute the gradient.
+        tmp<gVolType> tGrad;
+
+        // If the fvSolution dictionary contains an entry,
+        // use that, otherwise, default to leastSquares
+        word gradName("grad(" + field.name() + ')');
+
+        if (mesh_.schemesDict().subDict("gradSchemes").found(gradName))
+        {
+            tGrad = fvc::grad(field);
+        }
+        else
+        {
+            tGrad = fv::leastSquaresGrad<Type>(mesh_).grad(field);
+        }
+
+        // Make a new entry, but don't register the field.
+        gradTable.insert
+        (
+            field.name(),
+            autoPtr<gradType>
+            (
+                new gradType
+                (
+                    IOobject
+                    (
+                        tGrad().name(),
+                        mesh_.time().timeName(),
+                        mesh_,
+                        IOobject::NO_READ,
+                        IOobject::NO_WRITE,
+                        false
+                    ),
+                    tGrad()
+                )
+            )
+        );
+    }
+}
+
+
+//- Fetch the gradient field (template specialisation)
+template <>
+const volVectorField& topoMapper::gradient(const word& name) const
+{
+    if (!sGrads_.found(name))
+    {
+        FatalErrorIn
+        (
+            "const volVectorField& "
+            "topoMapper::gradient(const word& name) const"
+        ) << nl << " Gradient for: " << name
+          << " has not been stored."
+          << abort(FatalError);
+    }
+
+    return sGrads_[name]();
+}
+
+
+//- Fetch the gradient field (template specialisation)
+template <>
+const volTensorField& topoMapper::gradient(const word& name) const
+{
+    if (!vGrads_.found(name))
+    {
+        FatalErrorIn
+        (
+            "const volTensorField& "
+            "topoMapper::gradient(const word& name) const"
+        ) << nl << " Gradient for: " << name
+          << " has not been stored."
+          << abort(FatalError);
+    }
+
+    return vGrads_[name]();
+}
+
+
+//- Store gradients prior to mesh reset
+void topoMapper::storeGradients() const
+{
+    storeGradients<scalar>(sGrads_);
+    storeGradients<vector>(vGrads_);
+
+    if (fvMesh::debug)
+    {
+        Info << "Registered volScalarFields: " << endl;
+        Info << sGrads_.toc() << endl;
+
+        Info << "Registered volVectorFields: " << endl;
+        Info << vGrads_.toc() << endl;
+    }
+}
+
+
+//- Store geometric information
+void topoMapper::storeGeometry() const
+{
+    if (cellCentresPtr_)
+    {
+        deleteDemandDrivenData(cellVolumesPtr_);
+        deleteDemandDrivenData(cellCentresPtr_);
+
+        patchAreasPtr_.clear();
+        patchCentresPtr_.clear();
+    }
+
+    // Set the cell-volumes pointer.
+    cellVolumesPtr_ = new scalarField(mesh_.cellVolumes());
+
+    // Set the cell-centres pointer.
+    cellCentresPtr_ = new vectorField(mesh_.cellCentres());
+
+    // Set patch-areas
+    patchAreasPtr_.setSize(mesh_.boundaryMesh().size());
+
+    forAll(mesh_.boundaryMesh(), patchI)
+    {
+        patchAreasPtr_.set
+        (
+            patchI,
+            new scalarField
+            (
+                mag(mesh_.boundaryMesh()[patchI].faceAreas())
+            )
+        );
+    }
+
+    // Set patch-centres.
+    patchCentresPtr_.setSize(mesh_.boundaryMesh().size());
+
+    forAll(mesh_.boundaryMesh(), patchI)
+    {
+        patchCentresPtr_.set
+        (
+            patchI,
+            new vectorField
+            (
+                mesh_.boundaryMesh()[patchI].faceCentres()
+            )
+        );
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * *  //
+
+topoMapper::~topoMapper()
+{
+    clear();
+}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Return reference to the mesh
+const fvMesh& topoMapper::mesh() const
+{
+    return mesh_;
+}
+
+
+//- Return reference to objectRegistry storing fields.
+const objectRegistry& topoMapper::thisDb() const
+{
+    return mesh_;
+}
+
+
+//- Set mapping information
+void topoMapper::setMapper(const mapPolyMesh& mpm) const
+{
+    if
+    (
+        cellMap_.valid() ||
+        surfaceMap_.valid() ||
+        boundaryMap_.valid()
+    )
+    {
+        FatalErrorIn
+        (
+            "void topoMapper::setMapper() const"
+        ) << nl << " Mapper has already been set. "
+          << abort(FatalError);
+    }
+
+    // Set pointers
+    cellMap_.set(new topoCellMapper(mpm, *this));
+    surfaceMap_.set(new topoSurfaceMapper(mpm, *this));
+    boundaryMap_.set(new topoBoundaryMeshMapper(mesh(), mpm, *this));
+}
+
+
+//- Set face weighting information
+void topoMapper::setFaceWeights
+(
+    const Xfer<List<scalarField> >& weights,
+    const Xfer<List<vectorField> >& centres
+) const
+{
+    faceWeights_.transfer(weights());
+    faceCentres_.transfer(centres());
+}
+
+
+//- Set cell weighting information
+void topoMapper::setCellWeights
+(
+    const Xfer<List<scalarField> >& weights,
+    const Xfer<List<vectorField> >& centres
+) const
+{
+    cellWeights_.transfer(weights());
+    cellCentres_.transfer(centres());
+}
+
+
+//- Fetch face weights
+const List<scalarField>& topoMapper::faceWeights() const
+{
+    return faceWeights_;
+}
+
+
+//- Fetch cell weights
+const List<scalarField>& topoMapper::cellWeights() const
+{
+    return cellWeights_;
+}
+
+
+//- Fetch face centres
+const List<vectorField>& topoMapper::faceCentres() const
+{
+    return faceCentres_;
+}
+
+
+//- Fetch cell centres
+const List<vectorField>& topoMapper::cellCentres() const
+{
+    return cellCentres_;
+}
+
+
+//- Store mesh information for the mapping stage
+void topoMapper::storeMeshInformation() const
+{
+    // Store field-gradients
+    storeGradients();
+
+    // Store geometry
+    storeGeometry();
+}
+
+
+//- Return stored cell volume information
+const scalarField& topoMapper::cellVolumes() const
+{
+    if (!cellVolumesPtr_)
+    {
+        FatalErrorIn
+        (
+            "const scalarField& topoMapper::cellVolumes()"
+        ) << nl << " Pointer has not been set. "
+          << abort(FatalError);
+    }
+
+    return *cellVolumesPtr_;
+}
+
+
+//- Return stored cell centre information
+const vectorField& topoMapper::internalCentres() const
+{
+    if (!cellCentresPtr_)
+    {
+        FatalErrorIn
+        (
+            "const vectorField& topoMapper::internalCentres()"
+        ) << nl << " Pointer has not been set. "
+          << abort(FatalError);
+    }
+
+    return *cellCentresPtr_;
+}
+
+
+//- Return stored patch areas information
+const scalarField& topoMapper::patchAreas(const label i) const
+{
+    if (!patchAreasPtr_.set(i))
+    {
+        FatalErrorIn
+        (
+            "const scalarField& topoMapper::patchAreas"
+            "(const label i) const"
+        ) << nl << " Pointer has not been set at index: " << i
+          << abort(FatalError);
+    }
+
+    return patchAreasPtr_[i];
+}
+
+
+//- Return stored patch centre information
+const vectorField& topoMapper::patchCentres(const label i) const
+{
+    if (!patchCentresPtr_.set(i))
+    {
+        FatalErrorIn
+        (
+            "const vectorField& topoMapper::patchCentres"
+            "(const label i) const"
+        ) << nl << " Pointer has not been set at index: " << i
+          << abort(FatalError);
+    }
+
+    return patchCentresPtr_[i];
+}
+
+
+// Conservatively map all volFields in the registry
+template <class Type>
+void topoMapper::conservativeMapVolFields() const
+{
+    // Define a few typedefs for convenience
+    typedef typename outerProduct<vector, Type>::type gCmptType;
+    typedef GeometricField<Type, fvPatchField, volMesh> volType;
+    typedef GeometricField<gCmptType, fvPatchField, volMesh> gradVolType;
+
+    HashTable<const volType*> fields(mesh_.lookupClass<volType>());
+
+    // Store old-times before mapping
+    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        volType& field = const_cast<volType&>(*fIter());
+
+        field.storeOldTimes();
+    }
+
+    // Fetch internal/boundary mappers
+    const topoCellMapper& fMap = volMap();
+    const topoBoundaryMeshMapper& bMap = boundaryMap();
+
+    // Now map all fields
+    forAllIter(typename HashTable<const volType*>, fields, fIter)
+    {
+        volType& field = const_cast<volType&>(*fIter());
+
+        if (fvMesh::debug)
+        {
+            Info << "Conservatively mapping "
+                 << field.typeName
+                 << ' ' << field.name()
+                 << endl;
+        }
+
+        // Map the internal field
+        fMap.mapInternalField
+        (
+            field.name(),
+            gradient<gradVolType>(field.name()).internalField(),
+            field.internalField()
+        );
+
+        // Map patch fields
+        forAll(bMap, patchI)
+        {
+            bMap[patchI].mapPatchField
+            (
+                field.name(),
+                field.boundaryField()[patchI]
+            );
+        }
+
+        // Set the field instance
+        field.instance() = field.mesh().thisDb().time().timeName();
+    }
+}
+
+
+// Conservatively map all surfaceFields in the registry
+template <class Type>
+void topoMapper::conservativeMapSurfaceFields() const
+{
+    // Define a few typedefs for convenience
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfType;
+
+    HashTable<const surfType*> fields(mesh_.lookupClass<surfType>());
+
+    // Store old-times before mapping
+    forAllIter(typename HashTable<const surfType*>, fields, fIter)
+    {
+        surfType& field = const_cast<surfType&>(*fIter());
+
+        field.storeOldTimes();
+    }
+
+    // Fetch internal/boundary mappers
+    const topoSurfaceMapper& fMap = surfaceMap();
+    const topoBoundaryMeshMapper& bMap = boundaryMap();
+
+    // Now map all fields
+    forAllIter(typename HashTable<const surfType*>, fields, fIter)
+    {
+        surfType& field = const_cast<surfType&>(*fIter());
+
+        if (fvMesh::debug)
+        {
+            Info << "Conservatively mapping "
+                 << field.typeName
+                 << ' ' << field.name()
+                 << endl;
+        }
+
+        // Map the internal field
+        fMap.mapInternalField
+        (
+            field.name(),
+            field.internalField()
+        );
+
+        // Map patch fields
+        forAll(bMap, patchI)
+        {
+            bMap[patchI].mapPatchField
+            (
+                field.name(),
+                field.boundaryField()[patchI]
+            );
+        }
+
+        // Set the field instance
+        field.instance() = field.mesh().thisDb().time().timeName();
+    }
+}
+
+
+//- Correct fluxes after topology changes, if required
+void topoMapper::correctFluxes() const
+{
+    if (surfaceFluxCorrector().required())
+    {
+        // Supply a list of inserted faces for interpolation
+        surfaceFluxCorrector().interpolateFluxes
+        (
+            surfaceMap().insertedObjectLabels()
+        );
+
+        // Update fluxes
+        surfaceFluxCorrector().updateFluxes();
+    }
+}
+
+
+//- Return volume mapper
+const topoCellMapper& topoMapper::volMap() const
+{
+    if (!cellMap_.valid())
+    {
+        FatalErrorIn
+        (
+            "const topoCellMapper& topoMapper::volMap()"
+        ) << nl << " Volume mapper has not been set. "
+          << abort(FatalError);
+    }
+
+    return cellMap_();
+}
+
+
+//- Return surface mapper
+const topoSurfaceMapper& topoMapper::surfaceMap() const
+{
+    if (!surfaceMap_.valid())
+    {
+        FatalErrorIn
+        (
+            "const topoSurfaceMapper& topoMapper::surfaceMap()"
+        ) << nl << " Surface mapper has not been set. "
+          << abort(FatalError);
+    }
+
+    return surfaceMap_();
+}
+
+
+//- Return boundary mapper
+const topoBoundaryMeshMapper& topoMapper::boundaryMap() const
+{
+    if (!boundaryMap_.valid())
+    {
+        FatalErrorIn
+        (
+            "const topoBoundaryMeshMapper& topoMapper::boundaryMap()"
+        ) << nl << " Boundary mapper has not been set. "
+          << abort(FatalError);
+    }
+
+    return boundaryMap_();
+}
+
+
+//- Return flux-corrector
+const fluxCorrector& topoMapper::surfaceFluxCorrector() const
+{
+    if (!fluxCorrector_.valid())
+    {
+        FatalErrorIn
+        (
+            "const fluxCorrector& topoMapper::surfaceFluxCorrector()"
+        ) << nl << " fluxCorrector has not been set. "
+          << abort(FatalError);
+    }
+
+    return fluxCorrector_();
+}
+
+
+//- Clear out member data
+void topoMapper::clear()
+{
+    // Clear out mappers
+    cellMap_.clear();
+    surfaceMap_.clear();
+    boundaryMap_.clear();
+
+    // Clear stored gradients
+    sGrads_.clear();
+    vGrads_.clear();
+
+    // Wipe out geomtry information
+    deleteDemandDrivenData(cellVolumesPtr_);
+    deleteDemandDrivenData(cellCentresPtr_);
+    patchAreasPtr_.clear();
+    patchCentresPtr_.clear();
+
+    // Clear maps
+    faceWeights_.clear();
+    cellWeights_.clear();
+
+    faceCentres_.clear();
+    cellCentres_.clear();
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+void topoMapper::operator=(const topoMapper& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "topoMapper::operator=(const topoMapper&)"
+        )
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
new file mode 100644
index 000000000..67fd83ddc
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoMapper.H
@@ -0,0 +1,245 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoMapper
+
+Description
+    Class holds all necessary information for mapping fields associated with
+    dynamicTopoFvMesh and fvMesh.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    topoMapper.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef topoMapper_H
+#define topoMapper_H
+
+#include "fluxCorrector.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class topoCellMapper;
+class topoSurfaceMapper;
+class topoBoundaryMeshMapper;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                         Class topoMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class topoMapper
+{
+    // Private data
+
+        //- Reference to fvMesh
+        const fvMesh& mesh_;
+
+        //- Reference to the options dictionary
+        const dictionary& dict_;
+
+    // Demand-driven private data
+
+        //- Cell mapper
+        mutable autoPtr<topoCellMapper> cellMap_;
+
+        //- Surface mapper
+        mutable autoPtr<topoSurfaceMapper> surfaceMap_;
+
+        //- Boundary mapper
+        mutable autoPtr<topoBoundaryMeshMapper> boundaryMap_;
+
+        //- Flux corrector
+        mutable autoPtr<fluxCorrector> fluxCorrector_;
+
+        // Stored gradients for mapping
+        mutable HashTable<autoPtr<volVectorField> > sGrads_;
+        mutable HashTable<autoPtr<volTensorField> > vGrads_;
+
+        //- Geometric information on the old mesh
+        mutable scalarField* cellVolumesPtr_;
+        mutable vectorField* cellCentresPtr_;
+        mutable PtrList<scalarField> patchAreasPtr_;
+        mutable PtrList<vectorField> patchCentresPtr_;
+
+        //- Intersection volume weights
+        mutable List<scalarField> faceWeights_;
+        mutable List<scalarField> cellWeights_;
+
+        //- Intersection centre weights
+        mutable List<vectorField> faceCentres_;
+        mutable List<vectorField> cellCentres_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        topoMapper(const topoMapper&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const topoMapper&);
+
+        // Store gradients of volFields on the mesh
+        // prior to topology changes
+        template <class Type, class gradType>
+        void storeGradients
+        (
+            HashTable<autoPtr<gradType> >& gradTable
+        ) const;
+
+        //- Fetch the gradient field
+        template <class Type>
+        const Type& gradient(const word& name) const;
+
+        //- Store gradients prior to mesh reset
+        void storeGradients() const;
+
+        //- Set geometric information
+        void storeGeometry() const;
+
+public:
+
+    // Constructors
+
+        //- Construct from mesh and dictionary
+        topoMapper(const fvMesh& mesh, const dictionary& dict)
+        :
+            mesh_(mesh),
+            dict_(dict),
+            cellMap_(NULL),
+            surfaceMap_(NULL),
+            boundaryMap_(NULL),
+            fluxCorrector_(fluxCorrector::New(mesh, dict)),
+            cellVolumesPtr_(NULL),
+            cellCentresPtr_(NULL),
+            patchAreasPtr_(mesh.boundary().size()),
+            patchCentresPtr_(mesh.boundary().size())
+        {}
+
+    // Destructor
+
+        ~topoMapper();
+
+    // Member Functions
+
+        //- Return reference to the mesh
+        const fvMesh& mesh() const;
+
+        //- Return reference to objectRegistry storing fields.
+        const objectRegistry& thisDb() const;
+
+        //- Set mapping information
+        void setMapper(const mapPolyMesh& mpm) const;
+
+        //- Set face weighting information
+        void setFaceWeights
+        (
+            const Xfer<List<scalarField> >& weights,
+            const Xfer<List<vectorField> >& centres
+        ) const;
+
+        //- Set cell weighting information
+        void setCellWeights
+        (
+            const Xfer<List<scalarField> >& weights,
+            const Xfer<List<vectorField> >& centres
+        ) const;
+
+        //- Fetch face weights
+        const List<scalarField>& faceWeights() const;
+
+        //- Fetch cell weights
+        const List<scalarField>& cellWeights() const;
+
+        //- Fetch face centres
+        const List<vectorField>& faceCentres() const;
+
+        //- Fetch cell centres
+        const List<vectorField>& cellCentres() const;
+
+        //- Store mesh information for the mapping stage
+        void storeMeshInformation() const;
+
+        //- Return stored cell volume information
+        const scalarField& cellVolumes() const;
+
+        //- Return stored cell centre information
+        const vectorField& internalCentres() const;
+
+        //- Return stored patch area information
+        const scalarField& patchAreas(const label i) const;
+
+        //- Return stored patch centre information
+        const vectorField& patchCentres(const label i) const;
+
+        // Conservatively map all volFields in the registry
+        template <class Type>
+        void conservativeMapVolFields() const;
+
+        // Conservatively map all surfaceFields in the registry
+        template <class Type>
+        void conservativeMapSurfaceFields() const;
+
+        //- Correct fluxes after topology change
+        void correctFluxes() const;
+
+        //- Return volume mapper
+        const topoCellMapper& volMap() const;
+
+        //- Return surface mapper
+        const topoSurfaceMapper& surfaceMap() const;
+
+        //- Return boundary mapper
+        const topoBoundaryMeshMapper& boundaryMap() const;
+
+        //- Return flux-corrector
+        const fluxCorrector& surfaceFluxCorrector() const;
+
+        //- Clear out member data
+        void clear();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#ifdef NoRepository
+#include "topoMapper.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
new file mode 100644
index 000000000..fcc3c9e1d
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.C
@@ -0,0 +1,776 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoPatchMapper
+
+Description
+    Implementation of the topoPatchMapper class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "IOmanip.H"
+#include "topoMapper.H"
+#include "mapPolyMesh.H"
+#include "topoPatchMapper.H"
+#include "demandDrivenData.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+//- Clear out local storage
+void topoPatchMapper::clearOut()
+{
+    deleteDemandDrivenData(directAddrPtr_);
+    deleteDemandDrivenData(interpolationAddrPtr_);
+    deleteDemandDrivenData(weightsPtr_);
+    deleteDemandDrivenData(insertedFaceLabelsPtr_);
+    deleteDemandDrivenData(insertedFaceIndexMapPtr_);
+    deleteDemandDrivenData(insertedFaceAddressingPtr_);
+    deleteDemandDrivenData(areasPtr_);
+    deleteDemandDrivenData(centresPtr_);
+}
+
+
+//- Calculate the insertedFaceLabels list
+void topoPatchMapper::calcInsertedFaceAddressing() const
+{
+    if (insertedFaceLabelsPtr_ || insertedFaceAddressingPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoPatchMapper::calcInsertedFaceAddressing() const"
+        )   << " Inserted labels has already been calculated."
+            << abort(FatalError);
+    }
+
+    // Information from the old patch
+    const label oldPatchSize = mpm_.oldPatchSizes()[patch_.index()];
+    const label oldPatchStart = mpm_.oldPatchStarts()[patch_.index()];
+    const label oldPatchEnd = oldPatchStart + oldPatchSize;
+
+    // Allocate for inserted face labels and addressing
+    label nInsertedFaces = 0;
+
+    insertedFaceLabelsPtr_ = new labelList(patchSize(), -1);
+    labelList& insertedFaces = *insertedFaceLabelsPtr_;
+
+    insertedFaceIndexMapPtr_ = new labelList(patchSize(), -1);
+    labelList& insertedFacesMap = *insertedFaceIndexMapPtr_;
+
+    insertedFaceAddressingPtr_ = new labelListList(patchSize(), labelList(0));
+    labelListList& insertedAddressing = *insertedFaceAddressingPtr_;
+
+    // Fetch current patch start
+    label pStart = patch_.patch().start();
+
+    // Fetch the current boundary
+    const polyBoundaryMesh& boundary = mpm_.mesh().boundaryMesh();
+
+    // Loop through the facesFromFaces map, and ensure that
+    // inserted faces are only mapped from faces on the same patch.
+    const List<objectMap>& fff = mpm_.facesFromFacesMap();
+
+    forAll(fff, objectI)
+    {
+        const objectMap& fffI = fff[objectI];
+
+        // Only pick boundary faces in this patch
+        if (boundary.whichPatch(fffI.index()) == patch_.index())
+        {
+            if (fffI.masterObjects().empty())
+            {
+                FatalErrorIn
+                (
+                    "void topoPatchMapper::"
+                    "calcInsertedFaceAddressing() const"
+                )   << " Mapping for inserted boundary face is incorrect."
+                    << " Found an empty masterObjects list."
+                    << nl << " Face: " << fffI.index()
+                    << nl << " Patch: " << patch_.name()
+                    << abort(FatalError);
+            }
+            else
+            {
+                // Make an entry for the inserted label,
+                // and renumber addressing to patch.
+                insertedFaces[nInsertedFaces] = fffI.index() - pStart;
+
+                // Add a mapping entry for facesFromFaces indices
+                insertedFacesMap[nInsertedFaces] = objectI;
+
+                // Make an entry for addressing
+                labelList& addr = insertedAddressing[nInsertedFaces];
+
+                // Renumber addressing to patch.
+                // Also, check mapping for hits into
+                // other patches / internal faces.
+                addr = fffI.masterObjects();
+
+                forAll(addr, faceI)
+                {
+                    if
+                    (
+                        addr[faceI] >= oldPatchStart
+                     && addr[faceI] < oldPatchEnd
+                    )
+                    {
+                        addr[faceI] -= oldPatchStart;
+                    }
+                    else
+                    {
+                        FatalErrorIn
+                        (
+                            "void topoPatchMapper::"
+                            "calcInsertedFaceAddressing() const"
+                        )
+                            << "Addressing into another patch is not allowed."
+                            << nl << " Patch face index: " << faceI
+                            << nl << " addr[faceI]: " << addr[faceI]
+                            << nl << " oldPatchStart: " << oldPatchStart
+                            << nl << " oldPatchSize: " << oldPatchSize
+                            << nl << " oldPatchEnd: " << oldPatchEnd
+                            << abort(FatalError);
+                    }
+                }
+
+                nInsertedFaces++;
+            }
+        }
+    }
+
+    // Shorten inserted faces to actual size
+    insertedFaces.setSize(nInsertedFaces);
+    insertedFacesMap.setSize(nInsertedFaces);
+    insertedAddressing.setSize(nInsertedFaces);
+}
+
+
+//- Calculate addressing for mapping
+void topoPatchMapper::calcAddressing() const
+{
+    if (directAddrPtr_ || interpolationAddrPtr_)
+    {
+        FatalErrorIn("void topoPatchMapper::calcAddressing() const")
+            << "Addressing already calculated."
+            << abort(FatalError);
+    }
+
+    // Information from the old patch
+    const label oldPatchSize = mpm_.oldPatchSizes()[patch_.index()];
+    const label oldPatchStart = mpm_.oldPatchStarts()[patch_.index()];
+    const label oldPatchEnd = oldPatchStart + oldPatchSize;
+
+    // Assemble the maps: slice to patch
+    if (direct())
+    {
+        // Direct mapping - slice to size
+        directAddrPtr_ = new labelList(patch_.patch().patchSlice(mpm_.faceMap()));
+
+        labelList& addr = *directAddrPtr_;
+
+        // Shift to local patch indices.
+        // Also, check mapping for hits into other patches / internal faces.
+        forAll (addr, faceI)
+        {
+            if
+            (
+                addr[faceI] >= oldPatchStart
+             && addr[faceI] < oldPatchEnd
+            )
+            {
+                addr[faceI] -= oldPatchStart;
+            }
+            else
+            {
+                FatalErrorIn
+                (
+                    "void topoPatchMapper::calcAddressing() const"
+                )
+                    << "Addressing into another patch is not allowed."
+                    << nl << " Patch face index: " << faceI
+                    << nl << " addr[faceI]: " << addr[faceI]
+                    << nl << " oldPatchStart: " << oldPatchStart
+                    << nl << " oldPatchSize: " << oldPatchSize
+                    << nl << " oldPatchEnd: " << oldPatchEnd
+                    << abort(FatalError);
+            }
+        }
+    }
+    else
+    {
+        // Interpolative addressing
+        interpolationAddrPtr_ = new labelListList(patchSize(), labelList(0));
+        labelListList& addr = *interpolationAddrPtr_;
+
+        // Fetch the list of inserted faces / addressing
+        const labelList& insertedFaces = insertedObjectLabels();
+        const labelListList& insertedAddressing = insertedFaceAddressing();
+
+        // Make entries
+        forAll(insertedFaces, faceI)
+        {
+            addr[insertedFaces[faceI]] = insertedAddressing[faceI];
+        }
+
+        // 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());
+
+        forAll(fm, faceI)
+        {
+            if (fm[faceI] > -1 && addr[faceI].size() == 0)
+            {
+                // Mapped from a single face
+                label oldFace = fm[faceI];
+
+                if
+                (
+                    oldFace >= oldPatchStart
+                 && oldFace < oldPatchEnd
+                )
+                {
+                    oldFace -= oldPatchStart;
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "void topoPatchMapper::calcAddressing() const"
+                    )
+                        << "Addressing into another patch is not allowed."
+                        << nl << " Patch face index: " << faceI
+                        << nl << " faceMap[faceI]: " << oldFace
+                        << nl << " oldPatchStart: " << oldPatchStart
+                        << nl << " oldPatchSize: " << oldPatchSize
+                        << nl << " oldPatchEnd: " << oldPatchEnd
+                        << abort(FatalError);
+                }
+
+                addr[faceI] = labelList(1, oldFace);
+            }
+        }
+
+        // Check if we missed anything
+        forAll(addr, faceI)
+        {
+            if (addr[faceI].empty())
+            {
+                FatalErrorIn
+                (
+                    "void topoPatchMapper::calcAddressing() const"
+                )
+                    << "Addressing is missing." << nl
+                    << " Patch face index: " << faceI << nl
+                    << " nInsertedFaces: " << insertedFaces.size() << nl
+                    << " faceMap: " << fm[faceI] << nl
+                    << " Patch: " << patch_.name() << nl
+                    << abort(FatalError);
+            }
+        }
+    }
+}
+
+
+//- Calculate inverse-distance weights for interpolative mapping
+void topoPatchMapper::calcInverseDistanceWeights() const
+{
+    if (weightsPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoPatchMapper::calcInverseDistanceWeights() const"
+        )
+            << "Weights already calculated."
+            << abort(FatalError);
+    }
+
+    // Fetch interpolative addressing
+    const labelListList& addr = addressing();
+
+    // Allocate memory
+    weightsPtr_ = new scalarListList(patchSize());
+    scalarListList& w = *weightsPtr_;
+
+    // Obtain face-centre information from old/new meshes
+    const vectorField& oldCentres = tMapper_.patchCentres(patch_.index());
+    const vectorField& newCentres = patch_.patch().faceCentres();
+
+    forAll(addr, faceI)
+    {
+        const labelList& mo = addr[faceI];
+
+        // Do mapped faces
+        if (mo.size() == 1)
+        {
+            w[faceI] = scalarList(1, 1.0);
+        }
+        else
+        {
+            // Map from masters, inverse-distance weights
+            scalar totalWeight = 0.0;
+            w[faceI] = scalarList(mo.size(), 0.0);
+
+            forAll (mo, oldFaceI)
+            {
+                w[faceI][oldFaceI] =
+                (
+                    1.0/stabilise
+                    (
+                        magSqr
+                        (
+                            newCentres[faceI]
+                          - oldCentres[mo[oldFaceI]]
+                        ),
+                        VSMALL
+                    )
+                );
+
+                totalWeight += w[faceI][oldFaceI];
+            }
+
+            // Normalize weights
+            scalar normFactor = (1.0/totalWeight);
+
+            forAll (mo, oldFaceI)
+            {
+                w[faceI][oldFaceI] *= normFactor;
+            }
+        }
+    }
+}
+
+
+//- Calculate intersection weights for conservative mapping
+void topoPatchMapper::calcIntersectionWeightsAndCentres() const
+{
+    if (areasPtr_ || centresPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoPatchMapper::"
+            "calcIntersectionWeightsAndCentres() const"
+        )
+            << "Weights already calculated."
+            << abort(FatalError);
+    }
+
+    // Fetch interpolative addressing
+    const labelListList& addr = addressing();
+
+    // Allocate memory
+    areasPtr_ = new List<scalarField>(patchSize(), scalarField(0));
+    List<scalarField>& a = *areasPtr_;
+
+    centresPtr_ = new List<vectorField>(patchSize(), vectorField(0));
+    List<vectorField>& x = *centresPtr_;
+
+    // Obtain stored face-centres
+    const vectorField& faceCentres = tMapper_.patchCentres(patch_.index());
+
+    // Fetch maps
+    const List<vectorField>& mapFaceCentres = tMapper_.faceCentres();
+    const List<scalarField>& mapFaceWeights = tMapper_.faceWeights();
+
+    // Fill in maps first
+    const labelList& insertedFaces = insertedObjectLabels();
+    const labelList& insertedFacesMap = insertedObjectMap();
+
+    forAll(insertedFaces, faceI)
+    {
+        a[insertedFaces[faceI]] = mapFaceWeights[insertedFacesMap[faceI]];
+        x[insertedFaces[faceI]] = mapFaceCentres[insertedFacesMap[faceI]];
+    }
+
+    // Now do mapped faces
+    forAll(addr, faceI)
+    {
+        const labelList& mo = addr[faceI];
+
+        // Check if this is indeed a mapped face
+        if (mo.size() == 1 && x[faceI].empty() && a[faceI].empty())
+        {
+            x[faceI] = vectorField(1, faceCentres[mo[0]]);
+            a[faceI] = scalarField(1, 1.0);
+        }
+    }
+
+    // Final check to ensure everything went okay
+    forAll(a, faceI)
+    {
+        if (a[faceI].empty())
+        {
+            FatalErrorIn
+            (
+                "void topoPatchMapper::"
+                "calcIntersectionWeightsAndCentres() const"
+            )
+                << "Weights / centres is missing."
+                << nl << " Patch face index: " << faceI
+                << abort(FatalError);
+        }
+    }
+}
+
+
+const List<scalarField>& topoPatchMapper::intersectionWeights() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const List<scalarField>& "
+            "topoPatchMapper::intersectionWeights() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!areasPtr_)
+    {
+        calcIntersectionWeightsAndCentres();
+    }
+
+    return *areasPtr_;
+}
+
+
+const List<vectorField>& topoPatchMapper::intersectionCentres() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const List<vectorField>& "
+            "topoPatchMapper::intersectionCentres() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!centresPtr_)
+    {
+        calcIntersectionWeightsAndCentres();
+    }
+
+    return *centresPtr_;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+topoPatchMapper::topoPatchMapper
+(
+    const fvPatch& patch,
+    const mapPolyMesh& mpm,
+    const topoMapper& mapper
+)
+:
+    patch_(patch),
+    mpm_(mpm),
+    tMapper_(mapper),
+    direct_(false),
+    directAddrPtr_(NULL),
+    interpolationAddrPtr_(NULL),
+    weightsPtr_(NULL),
+    insertedFaceLabelsPtr_(NULL),
+    insertedFaceIndexMapPtr_(NULL),
+    insertedFaceAddressingPtr_(NULL),
+    areasPtr_(NULL),
+    centresPtr_(NULL)
+{
+    // Check for the possibility of direct mapping
+    if (insertedObjects())
+    {
+        direct_ = false;
+    }
+    else
+    {
+        direct_ = true;
+    }
+}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+topoPatchMapper::~topoPatchMapper()
+{
+    clearOut();
+}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Return the polyPatch size
+label topoPatchMapper::patchSize() const
+{
+    return patch_.patch().size();
+}
+
+
+//- Return size
+label topoPatchMapper::size() const
+{
+    return patch_.size();
+}
+
+
+//- Return size before mapping
+label topoPatchMapper::sizeBeforeMapping() const
+{
+    if (patch_.type() == "empty")
+    {
+        return 0;
+    }
+
+    return mpm_.oldPatchSizes()[patch_.index()];
+}
+
+
+//- Is the mapping direct
+bool topoPatchMapper::direct() const
+{
+    return direct_;
+}
+
+
+//- Return direct addressing
+const unallocLabelList& topoPatchMapper::directAddressing() const
+{
+    if (!direct())
+    {
+        FatalErrorIn
+        (
+            "const unallocLabelList& "
+            "topoPatchMapper::directAddressing() const"
+        )   << "Requested direct addressing for an interpolative mapper."
+            << abort(FatalError);
+    }
+
+    if (!directAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *directAddrPtr_;
+}
+
+
+//- Return interpolation addressing
+const labelListList& topoPatchMapper::addressing() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const labelListList& "
+            "topoPatchMapper::addressing() const"
+        )   << "Requested interpolative addressing for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!interpolationAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *interpolationAddrPtr_;
+}
+
+
+//- Return weights
+const scalarListList& topoPatchMapper::weights() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const scalarListList& "
+            "topoPatchMapper::weights() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!weightsPtr_)
+    {
+        calcInverseDistanceWeights();
+    }
+
+    return *weightsPtr_;
+}
+
+
+//- Are there any inserted faces
+bool topoPatchMapper::insertedObjects() const
+{
+    return insertedObjectLabels().size();
+}
+
+
+//- Return list of inserted faces
+const labelList& topoPatchMapper::insertedObjectLabels() const
+{
+    if (!insertedFaceLabelsPtr_)
+    {
+        calcInsertedFaceAddressing();
+    }
+
+    return *insertedFaceLabelsPtr_;
+}
+
+
+//- Return addressing map for inserted faces
+const labelList& topoPatchMapper::insertedObjectMap() const
+{
+    if (!insertedFaceIndexMapPtr_)
+    {
+        calcInsertedFaceAddressing();
+    }
+
+    return *insertedFaceIndexMapPtr_;
+}
+
+
+//- Return addressing for inserted faces
+const labelListList& topoPatchMapper::insertedFaceAddressing() const
+{
+    if (!insertedFaceAddressingPtr_)
+    {
+        calcInsertedFaceAddressing();
+    }
+
+    return *insertedFaceAddressingPtr_;
+}
+
+
+//- Map the patch field
+template <class Type>
+void topoPatchMapper::mapPatchField
+(
+    const word& fieldName,
+    Field<Type>& pF
+) const
+{
+    // To invoke inverse-distance weighting, use this:
+    // pF.autoMap(*this);
+
+    // Check for possibility of direct mapping
+    if (direct())
+    {
+        pF.autoMap(*this);
+    }
+    else
+    {
+        if (pF.size() != sizeBeforeMapping())
+        {
+            FatalErrorIn
+            (
+                "\n\n"
+                "void topoCellMapper::mapPatchField<Type>\n"
+                "(\n"
+                "    const word& fieldName,\n"
+                "    Field<Type>& iF\n"
+                ") const\n"
+            )  << "Incompatible size before mapping." << nl
+               << " Field: " << fieldName << nl
+               << " Field size: " << pF.size() << nl
+               << " map size: " << sizeBeforeMapping() << nl
+               << abort(FatalError);
+        }
+
+        // Fetch addressing
+        const labelListList& pAddressing = addressing();
+        const List<scalarField>& wF = intersectionWeights();
+
+        // Compute the integral of the source field
+        Type intSource = sum(pF * tMapper_.patchAreas(patch_.index()));
+
+        // Copy the original field
+        Field<Type> fieldCpy(pF);
+
+        // Resize to current dimensions
+        pF.setSize(size());
+
+        // Map the patch field
+        forAll(pF, faceI)
+        {
+            const labelList& addr = pAddressing[faceI];
+
+            pF[faceI] = pTraits<Type>::zero;
+
+            // Accumulate area-weighted interpolate
+            forAll(addr, faceJ)
+            {
+                pF[faceI] +=
+                (
+                    wF[faceI][faceJ] * fieldCpy[addr[faceJ]]
+                );
+            }
+        }
+
+        // Compute the integral of the target field
+        const polyPatch& ppI = mpm_.mesh().boundaryMesh()[patch_.index()];
+
+        Type intTarget = sum(pF * mag(ppI.faceAreas()));
+
+        if (polyMesh::debug)
+        {
+            int oldP = Info().precision();
+
+            // Compare the global integral
+            Info << " Field : " << fieldName
+                 << " Patch : " << ppI.name()
+                 << " integral errors : "
+                 << setprecision(15)
+                 << " source : " << mag(intSource)
+                 << " target : " << mag(intTarget)
+                 << " norm : "
+                 << (mag(intTarget - intSource) / (mag(intSource) + VSMALL))
+                 << setprecision(oldP)
+                 << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void topoPatchMapper::operator=(const topoPatchMapper& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn("void topoPatchMapper::operator=")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
new file mode 100644
index 000000000..c734d72c0
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoPatchMapper.H
@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoPatchMapper
+
+Description
+    This object provides mapping and fill-in information for patch data
+    between the two meshes after the topological change.  It is
+    constructed from mapPolyMesh.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    topoPatchMapper.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef topoPatchMapper_H
+#define topoPatchMapper_H
+
+#include "morphFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class topoMapper;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                    Class topoPatchMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class topoPatchMapper
+:
+    public fvPatchFieldMapper
+{
+    // Private data
+
+        //- Reference to patch
+        const fvPatch& patch_;
+
+        //- Reference to mapPolyMesh
+        const mapPolyMesh& mpm_;
+
+        //- Reference to the topoMapper
+        const topoMapper& tMapper_;
+
+        //- Is the mapping direct
+        bool direct_;
+
+    // Demand-driven private data
+
+        //- Direct addressing
+        mutable labelList* directAddrPtr_;
+
+        //- Interpolated addressing
+        mutable labelListList* interpolationAddrPtr_;
+
+        //- Inverse-distance weights
+        mutable scalarListList* weightsPtr_;
+
+        //- Inserted faces
+        mutable labelList* insertedFaceLabelsPtr_;
+
+        //- Inserted face index map
+        mutable labelList* insertedFaceIndexMapPtr_;
+
+        //- Inserted face addressing
+        mutable labelListList* insertedFaceAddressingPtr_;
+
+        //- Interpolation areas
+        mutable List<scalarField>* areasPtr_;
+
+        //- Interpolation centres
+        mutable List<vectorField>* centresPtr_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        topoPatchMapper(const topoPatchMapper&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const topoPatchMapper&);
+
+        //- Calculate the insertedFace addressing list
+        void calcInsertedFaceAddressing() const;
+
+        //- Calculate addressing for mapping
+        void calcAddressing() const;
+
+        //- Calculate inverse-distance weights for interpolative mapping
+        void calcInverseDistanceWeights() const;
+
+        //- Calculate intersection weights for conservative mapping
+        void calcIntersectionWeightsAndCentres() const;
+
+        //- Return intersection area weights
+        const List<scalarField>& intersectionWeights() const;
+
+        //- Return intersection area centres
+        const List<vectorField>& intersectionCentres() const;
+
+        //- Clear out local storage
+        void clearOut();
+
+public:
+
+    // Constructors
+
+        //- Construct from mapPolyMesh
+        topoPatchMapper
+        (
+            const fvPatch& patch,
+            const mapPolyMesh& mpm,
+            const topoMapper& mapper
+        );
+
+    // Destructor
+
+        virtual ~topoPatchMapper();
+
+    // Member Functions
+
+        //- Return the polyPatch size
+        label patchSize() const;
+
+        //- Return size
+        virtual label size() const;
+
+        //- Return size of field before mapping
+        virtual label sizeBeforeMapping() const;
+
+        //- Is the mapping direct
+        virtual bool direct() const;
+
+        //- Return direct addressing
+        virtual const unallocLabelList& directAddressing() const;
+
+        //- Return interpolated addressing
+        virtual const labelListList& addressing() const;
+
+        //- Return interpolaion weights
+        virtual const scalarListList& weights() const;
+
+        //- Are there any inserted faces
+        virtual bool insertedObjects() const;
+
+        //- Return list of inserted faces
+        virtual const labelList& insertedObjectLabels() const;
+
+        //- Return addressing map for inserted faces
+        const labelList& insertedObjectMap() const;
+
+        //- Return addressing for inserted faces
+        const labelListList& insertedFaceAddressing() const;
+
+        //- Map the patch field
+        template <class Type>
+        void mapPatchField
+        (
+            const word& fieldName,
+            Field<Type>& pF
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#ifdef NoRepository
+#include "topoPatchMapper.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C
new file mode 100644
index 000000000..dfd507990
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.C
@@ -0,0 +1,364 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoSurfaceMapper
+
+Description
+    Implementation of the topoSurfaceMapper class
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "topoMapper.H"
+#include "mapPolyMesh.H"
+#include "topoSurfaceMapper.H"
+#include "demandDrivenData.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+//- Clear out local storage
+void topoSurfaceMapper::clearOut()
+{
+    deleteDemandDrivenData(directAddrPtr_);
+    deleteDemandDrivenData(interpolationAddrPtr_);
+    deleteDemandDrivenData(weightsPtr_);
+    deleteDemandDrivenData(insertedFaceLabelsPtr_);
+}
+
+
+//- Calculate the insertedFaceLabels list
+void topoSurfaceMapper::calcInsertedFaceLabels() const
+{
+    if (insertedFaceLabelsPtr_)
+    {
+        FatalErrorIn
+        (
+            "void topoSurfaceMapper::calcInsertedFaceLabels() const"
+        )   << " Inserted labels has already been calculated."
+            << abort(FatalError);
+    }
+
+    // Allocate for inserted face labels
+    label nInsertedFaces = 0;
+
+    insertedFaceLabelsPtr_ = new labelList(size(), -1);
+    labelList& insertedFaces = *insertedFaceLabelsPtr_;
+
+    label nIntFaces = size();
+
+    // Loop through the facesFromFaces map, and ensure that
+    // inserted internal faces are not mapped from any parent faces.
+    const List<objectMap>& fff = mpm_.facesFromFacesMap();
+
+    forAll(fff, objectI)
+    {
+        const objectMap& fffI = fff[objectI];
+
+        // Only pick internal faces
+        if (fffI.index() < nIntFaces)
+        {
+            insertedFaces[nInsertedFaces++] = fffI.index();
+        }
+    }
+
+    // Shorten inserted faces to actual size
+    insertedFaces.setSize(nInsertedFaces);
+}
+
+
+//- Calculate addressing for mapping
+void topoSurfaceMapper::calcAddressing() const
+{
+    if
+    (
+        directAddrPtr_
+     || interpolationAddrPtr_
+    )
+    {
+        FatalErrorIn("void topoSurfaceMapper::calcAddressing() const")
+            << "Addressing already calculated."
+            << abort(FatalError);
+    }
+
+    if (direct())
+    {
+        // Direct addressing, no weights - slice to size
+        directAddrPtr_ =
+        (
+            new labelList
+            (
+                labelList::subList(mpm_.faceMap(), size())
+            )
+        );
+
+        labelList& addr = *directAddrPtr_;
+
+        // Loop through the addressing list,
+        // and set dummy addressing for newly created faces.
+        forAll(addr, faceI)
+        {
+            if (addr[faceI] < 0)
+            {
+                addr[faceI] = 0;
+            }
+        }
+    }
+    else
+    {
+        FatalErrorIn("void topoSurfaceMapper::calcAddressing() const")
+            << " Request for interpolative addressing"
+            << " on internal surface fields. The surfaceMapper"
+            << " is not designed to do this. Interpolate volFields"
+            << " to surfaceFields instead."
+            << abort(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+topoSurfaceMapper::topoSurfaceMapper
+(
+    const mapPolyMesh& mpm,
+    const topoMapper& mapper
+)
+:
+    mesh_(mpm.mesh()),
+    mpm_(mpm),
+    tMapper_(mapper),
+    direct_(false),
+    directAddrPtr_(NULL),
+    interpolationAddrPtr_(NULL),
+    weightsPtr_(NULL),
+    insertedFaceLabelsPtr_(NULL)
+{
+    // Calculate the insertedFaces list
+    calcInsertedFaceLabels();
+
+    // Set to direct mapping.
+    direct_ = true;
+}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+topoSurfaceMapper::~topoSurfaceMapper()
+{
+    clearOut();
+}
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//- Return size
+label topoSurfaceMapper::size() const
+{
+    return mesh_.nInternalFaces();
+}
+
+
+//- Return size before mapping
+label topoSurfaceMapper::sizeBeforeMapping() const
+{
+    return mpm_.nOldInternalFaces();
+}
+
+
+//- Is the mapping direct
+bool topoSurfaceMapper::direct() const
+{
+    return direct_;
+}
+
+
+//- Return direct addressing
+const unallocLabelList& topoSurfaceMapper::directAddressing() const
+{
+    if (!direct())
+    {
+        FatalErrorIn
+        (
+            "const unallocLabelList& "
+            "topoSurfaceMapper::directAddressing() const"
+        )   << "Requested direct addressing for an interpolative mapper."
+            << abort(FatalError);
+    }
+
+    if (!directAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *directAddrPtr_;
+}
+
+
+//- Return interpolation addressing
+const labelListList& topoSurfaceMapper::addressing() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const labelListList& "
+            "topoSurfaceMapper::addressing() const"
+        )   << "Requested interpolative addressing for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!interpolationAddrPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *interpolationAddrPtr_;
+}
+
+
+//- Return weights
+const scalarListList& topoSurfaceMapper::weights() const
+{
+    if (direct())
+    {
+        FatalErrorIn
+        (
+            "const scalarListList& "
+            "topoSurfaceMapper::weights() const"
+        )   << "Requested interpolative weights for a direct mapper."
+            << abort(FatalError);
+    }
+
+    if (!weightsPtr_)
+    {
+        calcAddressing();
+    }
+
+    return *weightsPtr_;
+}
+
+
+//- Are there any inserted faces
+bool topoSurfaceMapper::insertedObjects() const
+{
+    return insertedObjectLabels().size();
+}
+
+
+//- Return list of inserted faces
+const labelList& topoSurfaceMapper::insertedObjectLabels() const
+{
+    if (!insertedFaceLabelsPtr_)
+    {
+        calcInsertedFaceLabels();
+    }
+
+    return *insertedFaceLabelsPtr_;
+}
+
+
+//- Return flux flip map
+const labelHashSet& topoSurfaceMapper::flipFaceFlux() const
+{
+    return mpm_.flipFaceFlux();
+}
+
+
+//- Map the internal field
+template <class Type>
+void topoSurfaceMapper::mapInternalField
+(
+    const word& fieldName,
+    Field<Type>& iF
+) const
+{
+    if (iF.size() != sizeBeforeMapping())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "void topoSurfaceMapper::mapInternalField<Type>\n"
+            "(\n"
+            "    Field<Type>& iF\n"
+            ") const\n"
+        )  << "Incompatible size before mapping." << nl
+           << " Field: " << fieldName << nl
+           << " Field size: " << iF.size() << nl
+           << " map size: " << sizeBeforeMapping() << nl
+           << abort(FatalError);
+    }
+
+    // Map the internal field
+    iF.autoMap(*this);
+
+    // Flip the flux
+    const labelList flipFaces = flipFaceFlux().toc();
+
+    forAll (flipFaces, i)
+    {
+        if (flipFaces[i] < iF.size())
+        {
+            iF[flipFaces[i]] *= -1.0;
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "\n\n"
+                "void topoSurfaceMapper::mapInternalField<Type>\n"
+                "(\n"
+                "    Field<Type>& iF\n"
+                ") const\n"
+            )  << "Cannot flip boundary face fluxes." << nl
+               << " Field: " << fieldName << nl
+               << " Field size: " << iF.size() << nl
+               << " Face flip index: " << flipFaces[i] << nl
+               << abort(FatalError);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void topoSurfaceMapper::operator=(const topoSurfaceMapper& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn("void topoSurfaceMapper::operator=")
+            << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H
new file mode 100644
index 000000000..548f8fdae
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/fieldMapping/topoSurfaceMapper.H
@@ -0,0 +1,176 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    topoSurfaceMapper
+
+Description
+    This object provides mapping and fill-in information for internal
+    face data between the two meshes after topological changes.
+    It is constructed from mapPolyMesh.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    topoSurfaceMapper.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef topoSurfaceMapper_H
+#define topoSurfaceMapper_H
+
+#include "morphFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Class forward declarations
+class topoMapper;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class topoSurfaceMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class topoSurfaceMapper
+:
+    public morphFieldMapper
+{
+    // Private data
+
+        //- Reference to polyMesh
+        const polyMesh& mesh_;
+
+        //- Reference to mapPolyMesh
+        const mapPolyMesh& mpm_;
+
+        //- Reference to the topoMapper
+        const topoMapper& tMapper_;
+
+        //- Is the mapping direct
+        bool direct_;
+
+    // Demand-driven private data
+
+        //- Direct addressing
+        mutable labelList* directAddrPtr_;
+
+        //- Interpolated addressing
+        mutable labelListList* interpolationAddrPtr_;
+
+        //- Inverse-distance weights
+        mutable scalarListList* weightsPtr_;
+
+        //- Inserted faces
+        mutable labelList* insertedFaceLabelsPtr_;
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        topoSurfaceMapper(const topoSurfaceMapper&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const topoSurfaceMapper&);
+
+        //- Calculate the insertedFaceLabels list
+        void calcInsertedFaceLabels() const;
+
+        //- Calculate addressing for mapping
+        void calcAddressing() const;
+
+        //- Clear out local storage
+        void clearOut();
+
+public:
+
+    // Constructors
+
+        //- Construct from mapPolyMesh
+        topoSurfaceMapper
+        (
+            const mapPolyMesh& mpm,
+            const topoMapper& mapper
+        );
+
+    // Destructor
+
+        virtual ~topoSurfaceMapper();
+
+    // Member Functions
+
+        //- Return size
+        virtual label size() const;
+
+        //- Return size before mapping
+        virtual label sizeBeforeMapping() const;
+
+        //- Is the mapping direct
+        virtual bool direct() const;
+
+        //- Return direct addressing
+        virtual const unallocLabelList& directAddressing() const;
+
+        //- Return interpolation addressing
+        virtual const labelListList& addressing() const;
+
+        //- Return weights
+        virtual const scalarListList& weights() const;
+
+        //- Are there any inserted faces
+        virtual bool insertedObjects() const;
+
+        //- Return list of inserted faces
+        virtual const labelList& insertedObjectLabels() const;
+
+        //- Return flux flip map
+        const labelHashSet& flipFaceFlux() const;
+
+        //- Map the internal field
+        template <class Type>
+        void mapInternalField
+        (
+            const word& fieldName,
+            Field<Type>& iF
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+#ifdef NoRepository
+#include "topoSurfaceMapper.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
new file mode 100644
index 000000000..8a3a0b11a
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.C
@@ -0,0 +1,930 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    meshOps
+
+Description
+    Various utility functions that perform mesh-related operations.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#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 "triPointRef.H"
+#include "tetPointRef.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+namespace meshOps
+{
+
+// Utility method to build a hull of cells
+// connected to the edge (for 2D simplical meshes)
+void constructPrismHull
+(
+    const label eIndex,
+    const UList<face>& faces,
+    const UList<cell>& cells,
+    const UList<label>& owner,
+    const UList<label>& neighbour,
+    const UList<labelList>& edgeFaces,
+    labelList& hullTriFaces,
+    labelList& hullCells
+)
+{
+    labelHashSet cellSet, triFaceSet;
+
+    // Obtain references
+    const labelList& eFaces = edgeFaces[eIndex];
+
+    // Loop through edgeFaces and add cells
+    forAll(eFaces, faceI)
+    {
+        label c0 = owner[eFaces[faceI]];
+        label c1 = neighbour[eFaces[faceI]];
+
+        if (!cellSet.found(c0))
+        {
+            // Add this cell
+            cellSet.insert(c0);
+
+            // Find associated triFaces and add them too
+            const cell& cC = cells[c0];
+
+            forAll(cC, faceJ)
+            {
+                const face& cF = faces[cC[faceJ]];
+
+                if ((cF.size() == 3) && !(triFaceSet.found(cC[faceJ])))
+                {
+                    triFaceSet.insert(cC[faceJ]);
+                }
+            }
+        }
+
+        if (!cellSet.found(c1) && (c1 != -1))
+        {
+            // Add this cell
+            cellSet.insert(c1);
+
+            // Find associated triFaces and add them too
+            const cell& cC = cells[c1];
+
+            forAll(cC, faceJ)
+            {
+                const face& cF = faces[cC[faceJ]];
+
+                if ((cF.size() == 3) && !(triFaceSet.found(cC[faceJ])))
+                {
+                    triFaceSet.insert(cC[faceJ]);
+                }
+            }
+        }
+    }
+
+    // Obtain lists from hashSets
+    hullCells = cellSet.toc();
+    hullTriFaces = triFaceSet.toc();
+}
+
+
+// Utility method to build a hull of cells (and faces)
+// around an edge (for 3D simplical meshes)
+void constructHull
+(
+    const label eIndex,
+    const UList<face>& faces,
+    const UList<edge>& edges,
+    const UList<cell>& cells,
+    const UList<label>& owner,
+    const UList<label>& neighbour,
+    const UList<labelList>& faceEdges,
+    const UList<labelList>& edgeFaces,
+    const UList<labelList>& edgePoints,
+    labelList& hullEdges,
+    labelList& hullFaces,
+    labelList& hullCells,
+    labelListList& ringEntities
+)
+{
+    // [1] hullEdges is an ordered list of edge-labels around eIndex,
+    //     but not connected to it.
+    //      - Ordering is in the same manner as edgePoints.
+    // [2] hullFaces is an ordered list of face-labels connected to eIndex.
+    //      - Ordering is in the same manner as edgePoints.
+    // [3] hullCells is an ordered list of cell-labels connected to eIndex.
+    //      - For boundary hulls, the last cell label is -1
+    // [4] ringEntities are edges and faces connected to eIndex[0] and eIndex[1]
+    //      - ringEntities[0]: edges connected to eIndex[0]
+    //      - ringEntities[1]: faces connected to eIndex[0]
+    //      - ringEntities[2]: edges connected to eIndex[1]
+    //      - ringEntities[3]: faces connected to eIndex[1]
+
+    bool found;
+    label otherPoint = -1, nextPoint = -1;
+
+    // Obtain a reference to this edge, and its edgeFaces
+    const edge& edgeToCheck = edges[eIndex];
+    const labelList& eFaces = edgeFaces[eIndex];
+    const labelList& hullVertices = edgePoints[eIndex];
+
+    // Loop through all faces of this edge and add them to hullFaces
+    forAll(eFaces, faceI)
+    {
+        const face& faceToCheck = faces[eFaces[faceI]];
+
+        // Find the isolated point on this face,
+        // and compare it with hullVertices
+        meshOps::findIsolatedPoint
+        (
+            faceToCheck,
+            edgeToCheck,
+            otherPoint,
+            nextPoint
+        );
+
+        found = false;
+
+        forAll(hullVertices, indexI)
+        {
+            if (hullVertices[indexI] == otherPoint)
+            {
+                // Fill in the position of this face on the hull
+                hullFaces[indexI] = eFaces[faceI];
+
+                // Obtain edges connected to top and bottom
+                // vertices of edgeToCheck
+                const labelList& fEdges = faceEdges[hullFaces[indexI]];
+
+                forAll(fEdges, edgeI)
+                {
+                    if
+                    (
+                        edges[fEdges[edgeI]]
+                     == edge(edgeToCheck[0], otherPoint)
+                    )
+                    {
+                        ringEntities[0][indexI] = fEdges[edgeI];
+                    }
+
+                    if
+                    (
+                        edges[fEdges[edgeI]]
+                     == edge(edgeToCheck[1], otherPoint)
+                    )
+                    {
+                        ringEntities[2][indexI] = fEdges[edgeI];
+                    }
+                }
+
+                // Depending on the orientation of this face,
+                // fill in hull cell indices as well
+                if (nextPoint == edgeToCheck[0])
+                {
+                    hullCells[indexI] = owner[eFaces[faceI]];
+                }
+                else
+                if (nextPoint == edgeToCheck[1])
+                {
+                    hullCells[indexI] = neighbour[eFaces[faceI]];
+                }
+                else
+                {
+                    // Something's terribly wrong
+                    FatalErrorIn("void meshOps::constructHull()")
+                        << nl << " Failed to construct hull. "
+                        << nl << " Possibly not a tetrahedral mesh. "
+                        << abort(FatalError);
+                }
+
+                if (hullCells[indexI] != -1)
+                {
+                    label nextI = hullVertices.fcIndex(indexI);
+                    label nextHullPoint = hullVertices[nextI];
+                    const cell& currCell = cells[hullCells[indexI]];
+
+                    // Look for the ring-faces
+                    forAll(currCell, faceI)
+                    {
+                        const face& cFace = faces[currCell[faceI]];
+
+                        // Check if this face contains edgeToCheck[0]
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(cFace),
+                                triFace
+                                (
+                                    edgeToCheck[0],
+                                    otherPoint,
+                                    nextHullPoint
+                                )
+                            )
+                        )
+                        {
+                            ringEntities[1][indexI] = currCell[faceI];
+                        }
+
+                        // Check if this face contains edgeToCheck[1]
+                        if
+                        (
+                            triFace::compare
+                            (
+                                triFace(cFace),
+                                triFace
+                                (
+                                    edgeToCheck[1],
+                                    nextHullPoint,
+                                    otherPoint
+                                )
+                            )
+                        )
+                        {
+                            ringEntities[3][indexI] = currCell[faceI];
+                        }
+                    }
+
+                    // Scan one the faces for the ring-edge
+                    const labelList& rFaceEdges =
+                    (
+                        faceEdges[ringEntities[1][indexI]]
+                    );
+
+                    forAll(rFaceEdges, edgeI)
+                    {
+                        if
+                        (
+                            edges[rFaceEdges[edgeI]]
+                         == edge(otherPoint,nextHullPoint)
+                        )
+                        {
+                            hullEdges[indexI] = rFaceEdges[edgeI];
+                            break;
+                        }
+                    }
+                }
+
+                // Done with this index. Break out.
+                found = true;
+                break;
+            }
+        }
+
+        // Throw an error if the point wasn't found
+        if (!found)
+        {
+            // Something's terribly wrong
+            FatalErrorIn("void meshOps::constructHull()")
+                << " Failed to construct hull. " << nl
+                << " edgeFaces connectivity is inconsistent. " << nl
+                << " Edge: " << eIndex << ":: " << edgeToCheck << nl
+                << " edgeFaces: " << eFaces << nl
+                << " edgePoints: " << hullVertices
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// Given a set of points and edges, find the shortest path
+// between the start and end point, using Dijkstra's algorithm.
+//  - Takes a Map of points and edges that use those points.
+//  - Edge weights are currently edge-lengths, but can easily be adapted.
+//  - Returns true if the endPoint was found by the algorithm.
+//  - The Map 'pi' returns a preceding point for every point in 'points'.
+//
+//  Algorithm is inspired by:
+//    Renaud Waldura
+//    Dijkstra's Shortest Path Algorithm in Java
+//    http://renaud.waldura.com/
+bool Dijkstra
+(
+    const Map<point>& points,
+    const Map<edge>& edges,
+    const label startPoint,
+    const label endPoint,
+    Map<label>& pi
+)
+{
+    bool foundEndPoint = false;
+
+    // Set of unvisited (Q) / visited (S) points and distances (d)
+    labelHashSet Q, S;
+    Map<scalar> d;
+
+    // Initialize distances to large values
+    forAllConstIter(Map<point>, points, pIter)
+    {
+        d.insert(pIter.key(), GREAT);
+    }
+
+    // Invert edges to make a local pointEdges list
+    Map<labelList> localPointEdges;
+
+    forAllConstIter(Map<edge>, edges, eIter)
+    {
+        const edge& edgeToCheck = eIter();
+
+        forAll(edgeToCheck, pointI)
+        {
+            if (!localPointEdges.found(edgeToCheck[pointI]))
+            {
+                localPointEdges.insert(edgeToCheck[pointI], labelList(0));
+            }
+
+            meshOps::sizeUpList
+            (
+                eIter.key(),
+                localPointEdges[edgeToCheck[pointI]]
+            );
+        }
+    }
+
+    // Mark the startPoint as having the smallest distance
+    d[startPoint] = 0.0;
+
+    // Add the startPoint to the list of unvisited points
+    Q.insert(startPoint);
+
+    while (Q.size())
+    {
+        // Step 1: Find the node with the smallest distance from the start.
+        labelHashSet::iterator smallest = Q.begin();
+
+        for
+        (
+            labelHashSet::iterator iter = ++Q.begin();
+            iter != Q.end();
+            iter++
+        )
+        {
+            if (d[iter.key()] < d[smallest.key()])
+            {
+                smallest = iter;
+            }
+        }
+
+        label pointIndex = smallest.key();
+        scalar smallestDistance = d[pointIndex];
+
+        // Move to the visited points list
+        S.insert(pointIndex);
+        Q.erase(pointIndex);
+
+        // Step 2: Build a list of points adjacent to pointIndex
+        //         but not in the visited list
+        DynamicList<label> adjacentPoints(10);
+
+        const labelList& pEdges = localPointEdges[pointIndex];
+
+        forAll(pEdges, edgeI)
+        {
+            const edge& edgeToCheck = edges[pEdges[edgeI]];
+
+            label otherPoint = edgeToCheck.otherVertex(pointIndex);
+
+            if (!S.found(otherPoint))
+            {
+                adjacentPoints.append(otherPoint);
+            }
+        }
+
+        // Step 3: Perform distance-based checks for adjacent points
+        forAll(adjacentPoints, pointI)
+        {
+            label adjPoint = adjacentPoints[pointI];
+
+            scalar distance =
+            (
+                mag(points[adjPoint] - points[pointIndex])
+              + smallestDistance
+            );
+
+            // Check if the end-point has been touched.
+            if (adjPoint == endPoint)
+            {
+                foundEndPoint = true;
+            }
+
+            if (distance < d[adjPoint])
+            {
+                // Update to the shorter distance
+                d[adjPoint] = distance;
+
+                // Update the predecessor
+                if (pi.found(adjPoint))
+                {
+                    pi[adjPoint] = pointIndex;
+                }
+                else
+                {
+                    pi.insert(adjPoint, pointIndex);
+                }
+
+                // Add to the list of unvisited points
+                Q.insert(adjPoint);
+            }
+        }
+    }
+
+    return foundEndPoint;
+}
+
+
+// Select a list of elements from connectivity,
+// and output to a VTK format
+void writeVTK
+(
+    const polyMesh& mesh,
+    const word& name,
+    const labelList& cList,
+    const label primitiveType,
+    const UList<point>& meshPoints,
+    const UList<edge>& edges,
+    const UList<face>& faces,
+    const UList<cell>& cells,
+    const UList<label>& owner
+)
+{
+    label nTotalCells = 0;
+    label nPoints = 0, nCells = 0;
+
+    // Estimate a size for points and cellPoints
+    pointField points(6*cList.size());
+
+    // Connectivity lists
+    labelListList cpList(cList.size());
+
+    // Create a map for local points
+    Map<label> pointMap, reversePointMap, reverseCellMap;
+
+    forAll(cList, cellI)
+    {
+        if (cList[cellI] < 0)
+        {
+            continue;
+        }
+
+        // Are we looking at points?
+        if (primitiveType == 0)
+        {
+            // Size the list
+            cpList[nCells].setSize(1);
+
+            cpList[nCells] = cList[cellI];
+
+            nTotalCells++;
+        }
+
+        // Are we looking at edges?
+        if (primitiveType == 1)
+        {
+            // Size the list
+            cpList[nCells].setSize(2);
+
+            const edge& tEdge = edges[cList[cellI]];
+
+            cpList[nCells][0] = tEdge[0];
+            cpList[nCells][1] = tEdge[1];
+
+            nTotalCells += 2;
+        }
+
+        // Are we looking at faces?
+        if (primitiveType == 2)
+        {
+            const face& tFace = faces[cList[cellI]];
+
+            if (tFace.size() == 3)
+            {
+                // Size the list
+                cpList[nCells].setSize(3);
+
+                // Write out in order
+                cpList[nCells][0] = tFace[0];
+                cpList[nCells][1] = tFace[1];
+                cpList[nCells][2] = tFace[2];
+
+                nTotalCells += 3;
+            }
+            else
+            if (tFace.size() == 4)
+            {
+                // Size the list
+                cpList[nCells].setSize(4);
+
+                // Write out in order
+                cpList[nCells][0] = tFace[0];
+                cpList[nCells][1] = tFace[1];
+                cpList[nCells][2] = tFace[2];
+                cpList[nCells][3] = tFace[3];
+
+                nTotalCells += 4;
+            }
+        }
+
+        // Are we looking at cells?
+        if (primitiveType == 3)
+        {
+            const cell& tCell = cells[cList[cellI]];
+
+            if (tCell.size() == 4)
+            {
+                // Point-ordering for tetrahedra
+                const face& baseFace = faces[tCell[0]];
+                const face& checkFace = faces[tCell[1]];
+
+                // Size the list
+                cpList[nCells].setSize(4);
+
+                // Get the fourth point
+                label apexPoint =
+                (
+                    meshOps::findIsolatedPoint(baseFace, checkFace)
+                );
+
+                // Something's wrong with connectivity.
+                if (apexPoint == -1)
+                {
+                    FatalErrorIn
+                    (
+                        "void writeVTK\n"
+                        "(\n"
+                        "    const polyMesh& mesh,\n"
+                        "    const word& name,\n"
+                        "    const labelList& cList,\n"
+                        "    const label primitiveType,\n"
+                        "    const UList<point>& points,\n"
+                        "    const UList<edge>& edges,\n"
+                        "    const UList<face>& faces,\n"
+                        "    const UList<cell>& cells,\n"
+                        "    const UList<label>& owner\n"
+                        ") const\n"
+                    )
+                        << "Cell: " << cList[cellI]
+                        << ":: " << tCell
+                        << " has inconsistent connectivity."
+                        << abort(FatalError);
+                }
+
+                // Write-out in order
+                label ownCell = owner[tCell[0]];
+
+                if (ownCell == cList[cellI])
+                {
+                    cpList[nCells][0] = baseFace[2];
+                    cpList[nCells][1] = baseFace[1];
+                    cpList[nCells][2] = baseFace[0];
+                    cpList[nCells][3] = apexPoint;
+                }
+                else
+                {
+                    cpList[nCells][0] = baseFace[0];
+                    cpList[nCells][1] = baseFace[1];
+                    cpList[nCells][2] = baseFace[2];
+                    cpList[nCells][3] = apexPoint;
+                }
+
+                nTotalCells += 4;
+            }
+            else
+            if (tCell.size() == 5)
+            {
+                // Point-ordering for wedge cells
+                label firstTriFace = -1;
+
+                // Size the list
+                cpList[nCells].setSize(6);
+
+                // Figure out triangle faces
+                forAll(tCell, faceI)
+                {
+                    const face& cFace = faces[tCell[faceI]];
+
+                    if (cFace.size() == 3)
+                    {
+                        if (firstTriFace == -1)
+                        {
+                            firstTriFace = tCell[faceI];
+
+                            // Right-handedness is assumed here.
+                            // Tri-faces are always on the boundary.
+                            cpList[nCells][0] = cFace[0];
+                            cpList[nCells][1] = cFace[1];
+                            cpList[nCells][2] = cFace[2];
+                        }
+                        else
+                        {
+                            // Detect the three other points.
+                            forAll(tCell, faceJ)
+                            {
+                                const face& nFace = faces[tCell[faceJ]];
+
+                                if (nFace.size() == 4)
+                                {
+                                    // Search for vertices on cFace
+                                    // in this face.
+                                    forAll(cFace, I)
+                                    {
+                                        label i = nFace.which(cFace[I]);
+
+                                        if (i != -1)
+                                        {
+                                            label p = nFace.prevLabel(i);
+                                            label n = nFace.nextLabel(i);
+
+                                            if (p == cpList[nCells][0])
+                                            {
+                                                cpList[nCells][3] = cFace[I];
+                                            }
+
+                                            if (p == cpList[nCells][1])
+                                            {
+                                                cpList[nCells][4] = cFace[I];
+                                            }
+
+                                            if (p == cpList[nCells][2])
+                                            {
+                                                cpList[nCells][5] = cFace[I];
+                                            }
+
+                                            if (n == cpList[nCells][0])
+                                            {
+                                                cpList[nCells][3] = cFace[I];
+                                            }
+
+                                            if (n == cpList[nCells][1])
+                                            {
+                                                cpList[nCells][4] = cFace[I];
+                                            }
+
+                                            if (n == cpList[nCells][2])
+                                            {
+                                                cpList[nCells][5] = cFace[I];
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            break;
+                        }
+                    }
+                }
+
+                nTotalCells += 6;
+            }
+        }
+
+        // Renumber to local ordering
+        forAll(cpList[nCells], pointI)
+        {
+            // Check if this point was added to the map
+            if (!pointMap.found(cpList[nCells][pointI]))
+            {
+                // Point was not found, so add it
+                points[nPoints] = meshPoints[cpList[nCells][pointI]];
+
+                // Update the map
+                pointMap.insert(cpList[nCells][pointI], nPoints);
+                reversePointMap.insert(nPoints, cpList[nCells][pointI]);
+
+                // Increment the number of points
+                nPoints++;
+            }
+
+            // Renumber it.
+            cpList[nCells][pointI] = pointMap[cpList[nCells][pointI]];
+        }
+
+        // Update the cell map.
+        reverseCellMap.insert(nCells, cList[cellI]);
+
+        nCells++;
+    }
+
+    // Finally write it out
+    meshOps::writeVTK
+    (
+        mesh,
+        name,
+        nPoints,
+        nCells,
+        nTotalCells,
+        points,
+        cpList,
+        primitiveType,
+        reversePointMap,
+        reverseCellMap
+    );
+}
+
+
+// Actual routine to write out the VTK file
+void writeVTK
+(
+    const polyMesh& mesh,
+    const word& name,
+    const label nPoints,
+    const label nCells,
+    const label nTotalCells,
+    const vectorField& points,
+    const labelListList& cpList,
+    const label primitiveType,
+    const Map<label>& reversePointMap,
+    const Map<label>& reverseCellMap
+)
+{
+    // Make the directory
+    fileName dirName(mesh.time().path()/"VTK"/mesh.time().timeName());
+
+    mkDir(dirName);
+
+    // Open stream for output
+    OFstream file(dirName/name+".vtk");
+
+    // Write out the header
+    file << "# vtk DataFile Version 2.0" << nl
+         << name << ".vtk" << nl
+         << "ASCII" << nl
+         << "DATASET UNSTRUCTURED_GRID" << nl
+         << "POINTS " << nPoints << " double" << nl;
+
+    for (label i = 0; i < nPoints; i++)
+    {
+        file << setprecision(15)
+             << points[i].x() << ' '
+             << points[i].y() << ' '
+             << points[i].z() << ' '
+             << nl;
+    }
+
+    file << "CELLS " << nCells << " " << nTotalCells + nCells << endl;
+
+    if (cpList.size())
+    {
+        forAll(cpList, i)
+        {
+            if (cpList[i].size())
+            {
+                file << cpList[i].size() << ' ';
+
+                forAll(cpList[i], j)
+                {
+                    file << cpList[i][j] << ' ';
+                }
+
+                file << nl;
+            }
+        }
+    }
+    else
+    {
+        // List of points
+        for (label i = 0; i < nPoints; i++)
+        {
+            file << 1 << ' ' << i << nl;
+        }
+    }
+
+    file << "CELL_TYPES " << nCells << endl;
+
+    if (cpList.size())
+    {
+        forAll(cpList, i)
+        {
+            if (cpList[i].size() == 1)
+            {
+                // Vertex
+                file << "1" << nl;
+            }
+
+            if (cpList[i].size() == 2)
+            {
+                // Edge
+                file << "3" << nl;
+            }
+
+            if (cpList[i].size() == 3)
+            {
+                // Triangle face
+                file << "5" << nl;
+            }
+
+            if
+            (
+                (cpList[i].size() == 4) &&
+                (primitiveType == 2)
+            )
+            {
+                // Quad face
+                file << "9" << nl;
+            }
+
+            if
+            (
+                (cpList[i].size() == 4) &&
+                (primitiveType == 3)
+            )
+            {
+                // Tetrahedron
+                file << "10" << nl;
+            }
+
+            if (cpList[i].size() == 6)
+            {
+                // Wedge
+                file << "13" << nl;
+            }
+        }
+    }
+    else
+    {
+        // List of points
+        for (label i = 0; i < nPoints; i++)
+        {
+            // Vertex
+            file << '1' << nl;
+        }
+    }
+
+    // Write out indices for visualization.
+    if (reverseCellMap.size())
+    {
+        file << "CELL_DATA " << nCells << endl;
+
+        file << "FIELD CellFields 1" << endl;
+
+        file << "CellIds 1 " << nCells << " int" << endl;
+
+        for (label i = 0; i < nCells; i++)
+        {
+            file << reverseCellMap[i] << ' ';
+        }
+
+        file << endl;
+    }
+
+    // Write out indices for visualization.
+    if (reversePointMap.size())
+    {
+        file << "POINT_DATA " << nPoints << endl;
+
+        file << "FIELD PointFields 1" << endl;
+
+        file << "PointIds 1 " << nPoints << " int" << endl;
+
+        for (label i = 0; i < nPoints; i++)
+        {
+            file << reversePointMap[i] << ' ';
+        }
+
+        file << endl;
+    }
+}
+
+
+} // End namespace meshOps
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
new file mode 100644
index 000000000..5b3c96052
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOps.H
@@ -0,0 +1,311 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    meshOps
+
+Description
+    Various utility functions that perform mesh-related operations.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    meshOpsI.H
+    meshOps.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef meshOps_H
+#define meshOps_H
+
+#include "Map.H"
+#include "line.H"
+#include "point.H"
+#include "label.H"
+#include "scalar.H"
+#include "HashSet.H"
+#include "cellList.H"
+#include "edgeList.H"
+#include "faceList.H"
+#include "triangle.H"
+#include "vectorField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Namespace meshOps Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace meshOps
+{
+    // Compute the centre for a given face, using UList
+    inline void faceCentre
+    (
+        const face& faceToCheck,
+        const UList<vector>& points,
+        vector& centre
+    );
+
+    // Compute the normal for a given face, using UList
+    inline void faceNormal
+    (
+        const face& faceToCheck,
+        const UList<vector>& points,
+        vector& normal
+    );
+
+    // Method to find the common-edge between two faces.
+    inline bool findCommonEdge
+    (
+        const label first,
+        const label second,
+        const UList<labelList>& faceEdges,
+        label& common
+    );
+
+    // Method to find the interior/boundary faces
+    // for an input quad-face and adjacent triangle-prism cell.
+    inline void findPrismFaces
+    (
+        const label fIndex,
+        const label cIndex,
+        const UList<face>& faces,
+        const UList<cell>& cells,
+        const UList<label>& neighbour,
+        FixedList<face,2>& bdyf,
+        FixedList<label,2>& bidx,
+        FixedList<face,2>& intf,
+        FixedList<label,2>& iidx
+    );
+
+    // Utility method to build a hull of cells
+    // connected to the edge (for 2D simplical meshes)
+    void constructPrismHull
+    (
+        const label eIndex,
+        const UList<face>& faces,
+        const UList<cell>& cells,
+        const UList<label>& owner,
+        const UList<label>& neighbour,
+        const UList<labelList>& edgeFaces,
+        labelList& hullTriFaces,
+        labelList& hullCells
+    );
+
+    // Utility method to build a hull of cells (and faces)
+    // around an edge (for 3D simplical meshes)
+    void constructHull
+    (
+        const label eIndex,
+        const UList<face>& faces,
+        const UList<edge>& edges,
+        const UList<cell>& cells,
+        const UList<label>& owner,
+        const UList<label>& neighbour,
+        const UList<labelList>& faceEdges,
+        const UList<labelList>& edgeFaces,
+        const UList<labelList>& edgePoints,
+        labelList& hullEdges,
+        labelList& hullFaces,
+        labelList& hullCells,
+        labelListList& ringEntities
+    );
+
+    // Utility method to find the isolated point
+    // given two triangular faces.
+    inline label findIsolatedPoint
+    (
+        const face& baseFace,
+        const face& checkFace
+    );
+
+    // Method to find the isolated point on a triangular face
+    // that doesn't lie on the specified edge
+    inline void findIsolatedPoint
+    (
+        const face& f,
+        const edge& e,
+        label& ptIndex,
+        label& nextPtIndex
+    );
+
+    // Given a face and cell index, find the apex point for a tet cell.
+    inline label tetApexPoint
+    (
+        const label cIndex,
+        const label fIndex,
+        const UList<face> faces,
+        const UList<cell> cells
+    );
+
+    // Given a cell index, find the centroid / volume of a cell.
+    template <class T1, class T2>
+    inline bool cellCentreAndVolume
+    (
+        const label cIndex,
+        const UList<Vector<T1> >& points,
+        const UList<face>& faces,
+        const UList<cell>& cells,
+        const UList<label>& owner,
+        Vector<T2>& centre,
+        T2& volume,
+        bool checkClosed = false
+    );
+
+    // Determine whether a segment intersects a triangular face
+    template <class T>
+    inline bool segmentTriFaceIntersection
+    (
+        const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
+        const line<Vector<T>, const Vector<T>&>& edgeToCheck,
+        const T& matchTol,
+        Vector<T>& intPoint
+    );
+
+    // Determine whether the particular point lies
+    // inside the given triangular face
+    template <class T>
+    inline bool pointInTriFace
+    (
+        const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
+        const Vector<T>& checkPoint,
+        const T& matchTol,
+        bool testCoplanarity
+    );
+
+    // Dijkstra's algorithm for the shortest path problem
+    bool Dijkstra
+    (
+        const Map<point>& points,
+        const Map<edge>& edges,
+        const label startPoint,
+        const label endPoint,
+        Map<label>& pi
+    );
+
+    // Method to insert labels in a face, so that
+    // right-handedness is preserved.
+    template <class T>
+    inline void insertPointLabels
+    (
+        const Vector<T>& refNorm,
+        const Field<Vector<T> >& points,
+        const labelHashSet& pLabels,
+        face& modFace
+    );
+
+    // Method to insert a label between two labels in a list
+    inline void insertLabel
+    (
+        const label newLabel,
+        const label labelA,
+        const label labelB,
+        labelList& list
+    );
+
+    // Utility method to replace a label in a given list
+    inline void replaceLabel
+    (
+         const label original,
+         const label replacement,
+         labelList& list
+    );
+
+    // Utility method to size-up the list to include an item
+    template <class Type>
+    inline void sizeUpList
+    (
+        const Type& item,
+        List<Type>& list
+    );
+
+    // Utility method to size-down the list to remove an item
+    template <class Type>
+    inline void sizeDownList
+    (
+        const Type& item,
+        List<Type>& list
+    );
+
+    // Remove an item at a particular index in the list
+    template <class Type>
+    inline void removeIndex
+    (
+        const label index,
+        List<Type>& list
+    );
+
+    // Select a list of elements from connectivity,
+    // and output to a VTK format
+    void writeVTK
+    (
+        const polyMesh& mesh,
+        const word& name,
+        const labelList& cList,
+        const label primitiveType,
+        const UList<point>& meshPoints,
+        const UList<edge>& edges,
+        const UList<face>& faces,
+        const UList<cell>& cells,
+        const UList<label>& owner
+    );
+
+    // Actual routine to write out the VTK file
+    void writeVTK
+    (
+        const polyMesh& mesh,
+        const word& name,
+        const label nPoints,
+        const label nCells,
+        const label nTotalCells,
+        const vectorField& points,
+        const labelListList& cpList = labelListList(0),
+        const label primitiveType = 3,
+        const Map<label>& reversePointMap = Map<label>(),
+        const Map<label>& reverseCellMap = Map<label>()
+    );
+
+} // End namespace meshOps
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "meshOpsI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
new file mode 100644
index 000000000..95ea37aff
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsI.H
@@ -0,0 +1,843 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    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
+{
+
+// Compute the centroid for a given face, using UList
+inline void faceCentre
+(
+    const face& faceToCheck,
+    const UList<vector>& points,
+    vector& centre
+)
+{
+    // Reset to zero
+    centre = vector::zero;
+
+    vector a(vector::zero);
+    vector b(vector::zero);
+    vector c(vector::zero);
+
+    // If the face is a triangle, do a direct calculation
+    // to avoid round-off error-related problems
+    if (faceToCheck.size() == 3)
+    {
+        a = points[faceToCheck[0]];
+        b = points[faceToCheck[1]];
+        c = points[faceToCheck[2]];
+
+        centre = ((1.0 / 3.0) * (a + b + c));
+
+        return;
+    }
+
+    label nPoints = faceToCheck.size();
+
+    register label pI;
+
+    // Store the centre point in c
+    for (pI = 0; pI < nPoints; pI++)
+    {
+        c += points[faceToCheck[pI]];
+    }
+
+    c /= nPoints;
+
+    scalar ta = 0.0;
+    scalar sumA = 0.0;
+    vector ttc = vector::zero;
+    vector sumAc = vector::zero;
+
+    for (pI = 0; pI < nPoints; pI++)
+    {
+        a = points[faceToCheck[pI]];
+        b = points[faceToCheck[(pI + 1) % nPoints]];
+
+        // Calculate 3*triangle centre
+        ttc = (a + b + c);
+
+        // Calculate 2*triangle area
+        ta = mag((a - c)^(b - c));
+
+        sumA += ta;
+        sumAc += ta*ttc;
+    }
+
+    if (sumA > VSMALL)
+    {
+        centre = (sumAc/(3.0 * sumA));
+    }
+    else
+    {
+        centre = c;
+    }
+}
+
+
+// Compute the normal for a given face, using UList
+inline void faceNormal
+(
+    const face& faceToCheck,
+    const UList<vector>& points,
+    vector& normal
+)
+{
+    // Reset to zero
+    normal = vector::zero;
+
+    vector a(vector::zero);
+    vector b(vector::zero);
+    vector c(vector::zero);
+
+    // If the face is a triangle, do a direct calculation
+    // to avoid round-off error-related problems
+    if (faceToCheck.size() == 3)
+    {
+        a = points[faceToCheck[0]];
+        b = points[faceToCheck[1]];
+        c = points[faceToCheck[2]];
+
+        normal = (0.5 * ((b - a)^(c - a)));
+
+        return;
+    }
+
+    label nPoints = faceToCheck.size();
+
+    register label pI;
+
+    // Store the centre point in c
+    for (pI = 0; pI < nPoints; pI++)
+    {
+        c += points[faceToCheck[pI]];
+    }
+
+    c /= nPoints;
+
+    for (pI = 0; pI < nPoints; pI++)
+    {
+        a = points[faceToCheck[pI]];
+        b = points[faceToCheck[(pI + 1) % nPoints]];
+
+        normal += (0.5 * ((b - a)^(c - a)));
+    }
+}
+
+
+// Utility method to find the common edge between two faces.
+inline bool findCommonEdge
+(
+    const label first,
+    const label second,
+    const UList<labelList>& faceEdges,
+    label& common
+)
+{
+    bool found = false;
+
+    const labelList& fEi = faceEdges[first];
+    const labelList& fEj = faceEdges[second];
+
+    forAll(fEi, edgeI)
+    {
+        forAll(fEj, edgeJ)
+        {
+            if (fEi[edgeI] == fEj[edgeJ])
+            {
+                common = fEi[edgeI];
+
+                found = true;
+                break;
+            }
+        }
+
+        if (found)
+        {
+            break;
+        }
+    }
+
+    return found;
+}
+
+
+// Utility method to find the interior (quad) / boundary (tri) faces
+// for an input quad-face and adjacent triangle-prism cell.
+inline void findPrismFaces
+(
+    const label fIndex,
+    const label cIndex,
+    const UList<face>& faces,
+    const UList<cell>& cells,
+    const UList<label>& neighbour,
+    FixedList<face,2>& bdyf,
+    FixedList<label,2>& bidx,
+    FixedList<face,2>& intf,
+    FixedList<label,2>& iidx
+)
+{
+    label indexO = 0, indexI = 0;
+
+    const cell& c = cells[cIndex];
+
+    forAll(c, i)
+    {
+        label faceIndex = c[i];
+
+        // Don't count the face under consideration
+        if (faceIndex != fIndex)
+        {
+            const face& fi = faces[faceIndex];
+
+            if (neighbour[faceIndex] == -1)
+            {
+                if (fi.size() == 3)
+                {
+                    // Triangular face on the boundary
+                    bidx[indexO] = faceIndex;
+                    bdyf[indexO++] = fi;
+                }
+                else
+                {
+                    // This seems to be a non-triangular face on the boundary
+                    // Consider this as "interior" and move on
+                    iidx[indexI] = faceIndex;
+                    intf[indexI++] = fi;
+                }
+            }
+            else
+            {
+                // Face on the interior
+                iidx[indexI] = faceIndex;
+                intf[indexI++] = fi;
+            }
+        }
+    }
+}
+
+
+// Utility method to find the isolated point given two triangular faces.
+//  - Returns the point on checkFace that does not belong to baseFace.
+inline label findIsolatedPoint
+(
+    const face& baseFace,
+    const face& checkFace
+)
+{
+    // Get the fourth point
+    forAll(checkFace, pointI)
+    {
+        if
+        (
+            checkFace[pointI] != baseFace[0] &&
+            checkFace[pointI] != baseFace[1] &&
+            checkFace[pointI] != baseFace[2]
+        )
+        {
+            return checkFace[pointI];
+        }
+    }
+
+    return -1;
+}
+
+
+// Utility method to find the isolated point on a triangular face
+// that doesn't lie on the specified edge. Also returns the point next to it.
+inline void findIsolatedPoint
+(
+    const face& f,
+    const edge& e,
+    label& ptIndex,
+    label& nextPtIndex
+)
+{
+    // Check the first point
+    if ( f[0] != e.start() && f[0] != e.end() )
+    {
+        ptIndex = f[0];
+        nextPtIndex = f[1];
+        return;
+    }
+
+    // Check the second point
+    if ( f[1] != e.start() && f[1] != e.end() )
+    {
+        ptIndex = f[1];
+        nextPtIndex = f[2];
+        return;
+    }
+
+    // Check the third point
+    if ( f[2] != e.start() && f[2] != e.end() )
+    {
+        ptIndex = f[2];
+        nextPtIndex = f[0];
+        return;
+    }
+
+    // This bit should never happen.
+    FatalErrorIn
+    (
+        "inline void meshOps::findIsolatedPoint"
+        "(const face&, const edge&, label&, label&)"
+    )
+        << "Cannot find isolated point in face " << f << endl
+        << " Using edge: " << e
+        << abort(FatalError);
+}
+
+
+// Given a face and cell index, find the apex point for a tet cell.
+inline label tetApexPoint
+(
+    const label cIndex,
+    const label fIndex,
+    const UList<face> faces,
+    const UList<cell> cells
+)
+{
+    label apexPoint = -1;
+    bool foundApex = false;
+
+    const cell& cellToCheck = cells[cIndex];
+    const face& baseFace = faces[fIndex];
+
+    forAll(cellToCheck, faceI)
+    {
+        const face& faceToCheck = faces[cellToCheck[faceI]];
+
+        apexPoint = findIsolatedPoint(baseFace, faceToCheck);
+
+        if (foundApex > -1)
+        {
+            foundApex = true;
+            break;
+        }
+    }
+
+    if (!foundApex)
+    {
+        Info << "fIndex: " << fIndex << ":: " << faces[fIndex] << endl;
+        Info << "cIndex: " << cIndex << ":: " << cellToCheck << endl;
+
+        forAll(cellToCheck, faceI)
+        {
+            Info << '\t' << cellToCheck[faceI] << ":: "
+                 << faces[cellToCheck[faceI]] << endl;
+        }
+
+        FatalErrorIn
+        (
+            "\n\n"
+            "inline label meshOps::tetApexPoint\n"
+            "(\n"
+            "    const label cIndex,\n"
+            "    const label fIndex,\n"
+            "    const UList<face> faces,\n"
+            "    const UList<cell> cells\n"
+            ")\n"
+        )
+            << "Could not find an apex point in cell: " << cIndex
+            << " given face: " << fIndex
+            << abort(FatalError);
+    }
+
+    return apexPoint;
+}
+
+
+// Given a cell index, find the centroid / volume of a cell.
+//  - If checking is enabled, return whether the cell is closed
+template <class T1, class T2>
+inline bool cellCentreAndVolume
+(
+    const label cIndex,
+    const UList<Vector<T1> >& points,
+    const UList<face>& faces,
+    const UList<cell>& cells,
+    const UList<label>& owner,
+    Vector<T2>& centre,
+    T2& volume,
+    bool checkClosed
+)
+{
+    // Reset inputs
+    volume = pTraits<T2>::zero;
+    centre = Vector<T2>::zero;
+
+    const cell& cellToCheck = cells[cIndex];
+
+    // Average face-centres to get an estimate centroid
+    Vector<T2> cEst(Vector<T2>::zero);
+    Vector<T2> fCentre(Vector<T2>::zero);
+    Vector<T2> fArea(Vector<T2>::zero);
+    Vector<T2> sumClosed(Vector<T2>::zero), sumMagClosed(Vector<T2>::zero);
+
+    const T2 three(3.0), four(4.0);
+    const T2 oneThird = (pTraits<T2>::one / three);
+    const T2 oneFourth = (pTraits<T2>::one / four);
+    const T2 threeFourths = (three / four);
+
+    forAll(cellToCheck, faceI)
+    {
+        const face& checkFace = faces[cellToCheck[faceI]];
+
+        if (checkFace.empty())
+        {
+            continue;
+        }
+
+        meshOps::faceCentre
+        (
+            checkFace,
+            points,
+            fCentre
+        );
+
+        cEst += fCentre;
+    }
+
+    cEst /= T2(cellToCheck.size());
+
+    forAll(cellToCheck, faceI)
+    {
+        const face& checkFace = faces[cellToCheck[faceI]];
+
+        if (checkFace.empty())
+        {
+            continue;
+        }
+
+        meshOps::faceNormal
+        (
+            checkFace,
+            points,
+            fArea
+        );
+
+        meshOps::faceCentre
+        (
+            checkFace,
+            points,
+            fCentre
+        );
+
+        // Flip if necessary
+        if (owner[cellToCheck[faceI]] != cIndex)
+        {
+            fArea *= -1.0;
+        }
+
+        // Calculate 3*face-pyramid volume
+        T2 pyr3Vol = fArea & (fCentre - cEst);
+
+        // Calculate face-pyramid centre
+        Vector<T2> pc = (threeFourths*fCentre) + (oneFourth*cEst);
+
+        // Accumulate volume-weighted face-pyramid centre
+        centre += pyr3Vol*pc;
+
+        // Accumulate face-pyramid volume
+        volume += pyr3Vol;
+
+        // Accumulate areas, if necessary
+        if (checkClosed)
+        {
+            sumClosed += fArea;
+            sumMagClosed += cmptMag(fArea);
+        }
+    }
+
+    centre /= volume + VSMALL;
+    volume *= oneThird;
+
+    if (checkClosed)
+    {
+        // Check the sum across components
+        T2 closed = pTraits<T2>::zero;
+
+        for (direction cmpt = 0; cmpt < vector::nComponents; cmpt++)
+        {
+            closed =
+            (
+                mag(sumClosed[cmpt]) / (sumMagClosed[cmpt] + VSMALL)
+            );
+
+            if (closed > 1e-06)
+            {
+                // Volume is invalid
+                return false;
+            }
+        }
+    }
+
+    // Volume is valid
+    return true;
+}
+
+
+// Determine whether a segment intersects a triangular face
+template <class T>
+inline bool segmentTriFaceIntersection
+(
+    const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
+    const line<Vector<T>, const Vector<T>&>& edgeToCheck,
+    const T& matchTol,
+    Vector<T>& intPoint
+)
+{
+    // Fetch references
+    const Vector<T>& p1 = edgeToCheck.start();
+    const Vector<T>& p2 = edgeToCheck.end();
+
+    const Vector<T>& a = faceToCheck.a();
+    const Vector<T>& b = faceToCheck.b();
+    const Vector<T>& c = faceToCheck.c();
+
+    // Define custom face-normal
+    Vector<T> n = (T(0.5) * ((b - a)^(c - a)));
+    n /= mag(n) + VSMALL;
+
+    // Compute uValue
+    T numerator = n & (a - p1);
+    T denominator = n & (p2 - p1);
+
+    // Check if the edge is parallel to the face
+    if (mag(denominator) < VSMALL)
+    {
+        return false;
+    }
+
+    T u = (numerator / denominator);
+    T tolerance = (matchTol * mag(p2 - p1));
+
+    // Check for intersection along line.
+    if ((u > tolerance) && (u < (pTraits<T>::one - tolerance)))
+    {
+        // Compute point of intersection
+        intPoint = p1 + u*(p2 - p1);
+
+        // Also make sure that intPoint lies within the face
+        if (pointInTriFace(faceToCheck, intPoint, matchTol, false))
+        {
+            return true;
+        }
+    }
+
+    // Failed to fall within edge-bounds, or within face
+    return false;
+}
+
+
+// Determine whether the particular point lies
+// inside the given triangular face
+template <class T>
+inline bool pointInTriFace
+(
+    const triangle<Vector<T>, const Vector<T>&>& faceToCheck,
+    const Vector<T>& cP,
+    const T& matchTol,
+    bool testCoplanarity
+)
+{
+    // Copy inputs
+    const Vector<T>& a = faceToCheck.a();
+    const Vector<T>& b = faceToCheck.b();
+    const Vector<T>& c = faceToCheck.c();
+
+    const T pointFive(0.5);
+
+    // Compute the normal
+    Vector<T> nf = (pointFive * ((b - a)^(c - a)));
+
+    if ( ((pointFive * ((b - a)^(cP - a))) & nf) < pTraits<T>::zero)
+    {
+        return false;
+    }
+
+    if ( ((pointFive * ((c - b)^(cP - b))) & nf) < pTraits<T>::zero)
+    {
+        return false;
+    }
+
+    if ( ((pointFive * ((a - c)^(cP - c))) & nf) < pTraits<T>::zero)
+    {
+        return false;
+    }
+
+    if (testCoplanarity)
+    {
+        Vector<T> ftp(a - cP);
+
+        // Normalize vectors
+        nf /= mag(nf) + VSMALL;
+        ftp /= mag(ftp) + VSMALL;
+
+        if (mag(ftp & nf) > matchTol)
+        {
+            return false;
+        }
+    }
+
+    // Passed test with all edges
+    return true;
+}
+
+
+// Method to insert labels in a face, so that
+// right-handedness is preserved.
+template <class T>
+inline void insertPointLabels
+(
+    const Vector<T>& refNorm,
+    const Field<Vector<T> >& points,
+    const labelHashSet& pLabels,
+    face& modFace
+)
+{
+    // Need to configure a new face.
+    face newFace(modFace);
+
+    const T pointFive(0.5);
+
+    forAllConstIter(labelHashSet, pLabels, pIter)
+    {
+        forAll(newFace, pI)
+        {
+            label nI = newFace.fcIndex(pI);
+
+            const Vector<T>& a = points[newFace[pI]];
+            const Vector<T>& b = points[pIter.key()];
+            const Vector<T>& c = points[newFace[nI]];
+
+            // Compute the normal.
+            Vector<T> newNorm = (pointFive * ((b - a)^(c - a)));
+
+            if ((refNorm & newNorm) > pTraits<T>::zero)
+            {
+                // Insert the point.
+                meshOps::insertLabel
+                (
+                    pIter.key(),
+                    newFace[pI],
+                    newFace[nI],
+                    newFace
+                );
+
+                break;
+            }
+        }
+    }
+
+    // Take over storage
+    modFace.transfer(newFace);
+}
+
+
+// Method to insert a label between two labels in a list
+// Assumes that all labels are unique.
+inline void insertLabel
+(
+    const label newLabel,
+    const label labelA,
+    const label labelB,
+    labelList& list
+)
+{
+    // Create a new list
+    bool found = false;
+    label origSize = list.size();
+    labelList newList(origSize + 1);
+
+    label index = 0, nextI = -1;
+
+    // Start a linear search
+    forAll(list, itemI)
+    {
+        newList[index++] = list[itemI];
+
+        nextI = list.fcIndex(itemI);
+
+        if
+        (
+            (
+                (list[itemI] == labelA && list[nextI] == labelB) ||
+                (list[itemI] == labelB && list[nextI] == labelA)
+            ) &&
+           !found
+        )
+        {
+            found = true;
+            newList[index++] = newLabel;
+        }
+    }
+
+    if (!found)
+    {
+        FatalErrorIn
+        (
+            "inline void meshOps::insertLabel"
+            "(const label, const label, const label, labelList&)"
+        )   << nl << "Cannot insert " << newLabel
+            << " in list: " << list << nl
+            << " Labels: "
+            << labelA << " and " << labelB
+            << " were not found in sequence."
+            << abort(FatalError);
+    }
+
+    // Transfer the list
+    list.transfer(newList);
+}
+
+
+// Utility method to replace a label in a given list
+inline void replaceLabel
+(
+     const label original,
+     const label replacement,
+     labelList& list
+)
+{
+    label index = -1;
+
+    if ((index = findIndex(list, original)) > -1)
+    {
+        list[index] = replacement;
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "inline void label meshOps::replaceLabel"
+            "(const label, const label, labelList&)"
+        )   << nl << "Cannot find " << original
+            << " in list: " << list << nl
+            << " Label: " << replacement
+            << " was not used in replacement."
+            << abort(FatalError);
+    }
+}
+
+
+// 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/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.C b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.C
new file mode 100644
index 000000000..a119596f2
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.C
@@ -0,0 +1,1042 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    lengthScaleEstimator
+
+Description
+    Implementation of lengthScaleEstimator members
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+\*----------------------------------------------------------------------------*/
+
+#include "volFields.H"
+#include "lengthScaleEstimator.H"
+#include "processorPolyPatch.H"
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(lengthScaleEstimator,0);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from polyMesh and dictionary
+lengthScaleEstimator::lengthScaleEstimator
+(
+    const polyMesh& mesh
+)
+:
+    mesh_(mesh),
+    ratioMin_(0.0),
+    ratioMax_(0.0),
+    growthFactor_(1.0),
+    minLengthScale_(VSMALL),
+    maxLengthScale_(GREAT),
+    curvatureDeviation_(0.0),
+    spatialRes_(-1),
+    proximityBins_(0),
+    sliceThreshold_(VSMALL),
+    sliceHoldOff_(0),
+    sliceBoxes_(0),
+    field_("none"),
+    fieldLength_(0.0),
+    lowerRefineLevel_(0.001),
+    upperRefineLevel_(0.999),
+    meanScale_(-1.0),
+    maxRefineLevel_(labelMax)
+{}
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+lengthScaleEstimator::~lengthScaleEstimator()
+{}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+// Check for legitimacy of patches
+void lengthScaleEstimator::checkPatches(const wordList& patchList) const
+{
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    forAll(patchList, wordI)
+    {
+        if (boundary.findPatchID(patchList[wordI]) < 0)
+        {
+            FatalErrorIn
+            (
+                "void lengthScaleEstimator::checkPatches"
+                "(const wordList& patchList) const"
+            )
+                << " Could not find patch: "
+                << patchList[wordI] << nl
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// Prepare for proximity-based refinement, if necessary
+void lengthScaleEstimator::prepareProximityPatches()
+{
+    if (!proximityPatches_.size())
+    {
+        return;
+    }
+
+    if (debug)
+    {
+        Info << "Preparing patches for proximity-based refinement...";
+    }
+
+    // Clear out existing lists.
+    proximityBins_.clear();
+    proximityBins_.setSize(997, labelList(0));
+
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    bool setSpatialRes = false;
+
+    // Loop through all proximity patches and spatially hash patch faces.
+    forAll(boundary, patchI)
+    {
+        if
+        (
+            (proximityPatches_.found(boundary[patchI].name())) ||
+            (boundary[patchI].type() == "symmetryPlane")
+        )
+        {
+            const polyPatch& proxPatch = boundary[patchI];
+
+            // Construct a bounding-box of face centres.
+            // Do not synchronize in parallel, since the patch
+            // may not be present on all sub-domains.
+            boundBox box(proxPatch.faceCentres(), false);
+
+            const point& bMin = box.min();
+            const point& bMax = box.max();
+
+            // Further hashing requires this information.
+            proxBoundBox_.min() = bMin;
+            proxBoundBox_.max() = bMax;
+
+            // Build a list of face indices
+            labelList faceIndices
+            (
+                identity(proxPatch.size()) + proxPatch.start()
+            );
+
+            // For spatial resolution, pick a face on this patch.
+            if (!setSpatialRes)
+            {
+                scalar eLength =
+                (
+                    Foam::sqrt(mag(proxPatch.faceAreas()[0]))
+                );
+
+                spatialRes_ =
+                (
+                    label(::floor(mag(bMax - bMin) / (3.0 * eLength)))
+                );
+
+                setSpatialRes = true;
+            }
+
+            spatialHash
+            (
+                proxPatch.faceCentres(),
+                faceIndices,
+                box,
+                spatialRes_,
+                proximityBins_
+            );
+        }
+    }
+
+    if (debug)
+    {
+        Info << "Done." << endl;
+    }
+}
+
+
+// Perform spatial hashing on a set of points
+void lengthScaleEstimator::spatialHash
+(
+    const pointField& pointLocations,
+    const labelList& pointIndices,
+    const boundBox& box,
+    const label resolution,
+    labelListList& bins
+)
+{
+    label binSize = bins.size(), nD = resolution;
+
+    const point& bMin = box.min();
+    const point& bMax = box.max();
+
+    // Extend bounding-box dimensions a bit to avoid edge-effects.
+    scalar ext = 0.02*(mag(bMax - bMin));
+
+    // Define an inverse grid-cell size.
+    scalar xL = nD/(bMax.x() - bMin.x() + ext);
+    scalar yL = nD/(bMax.y() - bMin.y() + ext);
+    scalar zL = nD/(bMax.z() - bMin.z() + ext);
+
+    // Loop through all points and bin them.
+    forAll(pointLocations, pointI)
+    {
+        // Translate to boundBox minimum.
+        point p = pointLocations[pointI] - bMin;
+
+        // Hash the position.
+        label i = label(mag(::floor(p.x()*xL)));
+        label j = label(mag(::floor(p.y()*yL)));
+        label k = label(mag(::floor(p.z()*zL)));
+
+        label pos = mag(((k*nD*nD)+(j*nD)+i) % binSize);
+
+        // Store the index.
+        label newSize = bins[pos].size() + 1;
+        bins[pos].setSize(newSize, pointIndices[pointI]);
+    }
+}
+
+
+// Send length-scale info across processors
+void lengthScaleEstimator::writeLengthScaleInfo
+(
+    const labelList& cellLevels,
+    const scalarList& lengthScale
+)
+{
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    // Clear existing buffers
+    sendLblBuffer_.clear();
+    recvLblBuffer_.clear();
+    sendSclBuffer_.clear();
+    recvSclBuffer_.clear();
+
+    // Number of sent faces across processors
+    labelList nSendFaces(boundary.size(), 0);
+    labelList nRecvFaces(boundary.size(), 0);
+
+    // Corresponding face labels
+    sendLblBuffer_.setSize(boundary.size());
+    recvLblBuffer_.setSize(boundary.size());
+
+    // Length-scales corresponding to face-labels
+    sendSclBuffer_.setSize(boundary.size());
+    recvSclBuffer_.setSize(boundary.size());
+
+    // Fill send buffers with cell-level and length-scale info.
+    forAll(boundary, pI)
+    {
+        if (isA<processorPolyPatch>(boundary[pI]))
+        {
+            const labelList& fCells = boundary[pI].faceCells();
+
+            // Set the initial buffer size
+            sendLblBuffer_[pI].setSize(boundary[pI].size(), 0);
+            sendSclBuffer_[pI].setSize(boundary[pI].size(), 0.0);
+
+            forAll(fCells, faceI)
+            {
+                label cI = fCells[faceI];
+
+                // Does the adjacent cell have a non-zero level?
+                if (cellLevels[cI] > 0)
+                {
+                    // Fill the send buffer.
+                    sendLblBuffer_[pI][nSendFaces[pI]] = faceI;
+                    sendSclBuffer_[pI][nSendFaces[pI]] = lengthScale[cI];
+
+                    nSendFaces[pI]++;
+                }
+            }
+
+            // Resize to actual value
+            sendLblBuffer_[pI].setSize(nSendFaces[pI]);
+            sendSclBuffer_[pI].setSize(nSendFaces[pI]);
+
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[pI])
+            );
+
+            label neiProcNo = pp.neighbProcNo();
+
+            // First perform a blocking send/receive of the number of faces.
+            OPstream::write
+            (
+                Pstream::blocking,
+                neiProcNo,
+                reinterpret_cast<const char*>(&(nSendFaces[pI])),
+                sizeof(label)
+            );
+
+            IPstream::read
+            (
+                Pstream::blocking,
+                neiProcNo,
+                reinterpret_cast<char*>(&(nRecvFaces[pI])),
+                sizeof(label)
+            );
+        }
+    }
+
+    // Send info to neighbouring processors.
+    forAll(boundary, patchI)
+    {
+        if (isA<processorPolyPatch>(boundary[patchI]))
+        {
+            const processorPolyPatch& pp =
+            (
+                refCast<const processorPolyPatch>(boundary[patchI])
+            );
+
+            label neiProcNo = pp.neighbProcNo();
+
+            if (debug > 4)
+            {
+                Pout << " Processor patch " << patchI << ' ' << pp.name()
+                     << " communicating with " << neiProcNo
+                     << "  Sending: " << nSendFaces[patchI]
+                     << endl;
+            }
+
+            // Next, perform a non-blocking send/receive of buffers.
+            // But only if the buffer size is non-zero.
+            if (nSendFaces[patchI] != 0)
+            {
+                OPstream::write
+                (
+                    Pstream::nonBlocking,
+                    neiProcNo,
+                    reinterpret_cast<const char*>(&(sendLblBuffer_[patchI][0])),
+                    sendLblBuffer_[patchI].size()*sizeof(label)
+                );
+
+                OPstream::write
+                (
+                    Pstream::nonBlocking,
+                    neiProcNo,
+                    reinterpret_cast<const char*>(&(sendSclBuffer_[patchI][0])),
+                    sendSclBuffer_[patchI].size()*sizeof(scalar)
+                );
+            }
+
+            if (nRecvFaces[patchI] != 0)
+            {
+                // Size the receive buffers
+                recvLblBuffer_[patchI].setSize(nRecvFaces[patchI], 0);
+                recvSclBuffer_[patchI].setSize(nRecvFaces[patchI], 0.0);
+
+                IPstream::read
+                (
+                    Pstream::nonBlocking,
+                    neiProcNo,
+                    reinterpret_cast<char*>(&(recvLblBuffer_[patchI][0])),
+                    nRecvFaces[patchI]*sizeof(label)
+                );
+
+                IPstream::read
+                (
+                    Pstream::nonBlocking,
+                    neiProcNo,
+                    reinterpret_cast<char*>(&(recvSclBuffer_[patchI][0])),
+                    nRecvFaces[patchI]*sizeof(label)
+                );
+            }
+        }
+    }
+}
+
+
+// Receive length-scale info across processors
+void lengthScaleEstimator::readLengthScaleInfo
+(
+    const label level,
+    label& visitedCells,
+    labelList& cellLevels,
+    UList<scalar>& lengthScale,
+    labelHashSet& levelCells
+) const
+{
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    const labelList& own = mesh_.faceOwner();
+    const labelList& nei = mesh_.faceNeighbour();
+
+    // Wait for all transfers to complete.
+    OPstream::waitRequests();
+    IPstream::waitRequests();
+
+    // Now re-visit cells and update length-scales.
+    forAll(boundary, patchI)
+    {
+        if (recvLblBuffer_[patchI].size())
+        {
+            const labelList& fCells = boundary[patchI].faceCells();
+
+            forAll(recvLblBuffer_[patchI], i)
+            {
+                label nLabel = recvLblBuffer_[patchI][i];
+
+                label cI = fCells[nLabel];
+
+                label& ngbLevel = cellLevels[cI];
+
+                // For an unvisited cell, update the level
+                if (ngbLevel == 0)
+                {
+                    ngbLevel = level + 1;
+                    levelCells.insert(cI);
+                    visitedCells++;
+                }
+
+                // Visit all neighbours and re-calculate length-scale
+                const cell& cellCheck = mesh_.cells()[cI];
+
+                scalar sumLength = 0.0;
+                label nTouchedNgb = 0;
+
+                forAll(cellCheck, faceI)
+                {
+                    label sLevel = -1, sLCell = -1;
+                    label pF = boundary.whichPatch(cellCheck[faceI]);
+
+                    if (pF == -1)
+                    {
+                        // Internal face. Determine neighbour.
+                        if (own[cellCheck[faceI]] == cI)
+                        {
+                            sLCell = nei[cellCheck[faceI]];
+                        }
+                        else
+                        {
+                            sLCell = own[cellCheck[faceI]];
+                        }
+
+                        sLevel = cellLevels[sLCell];
+
+                        if ((sLevel < ngbLevel) && (sLevel > 0))
+                        {
+                            sumLength += lengthScale[sLCell];
+
+                            nTouchedNgb++;
+                        }
+                    }
+                    else
+                    if (isA<processorPolyPatch>(boundary[pF]))
+                    {
+                        // Determine the local index.
+                        label local = boundary[pF].whichFace(cellCheck[faceI]);
+
+                        // Is this label present in the list?
+                        forAll(recvLblBuffer_[pF], j)
+                        {
+                            if (recvLblBuffer_[pF][j] == local)
+                            {
+                                sumLength += recvSclBuffer_[pF][j];
+
+                                nTouchedNgb++;
+
+                                break;
+                            }
+                        }
+                    }
+                    else
+                    if (fixedPatches_.found(boundary[pF].name()))
+                    {
+                        sumLength +=
+                        (
+                            fixedPatches_[boundary[pF].name()][0].scalarToken()
+                        );
+
+                        nTouchedNgb++;
+                    }
+                }
+
+                sumLength /= nTouchedNgb;
+
+                // Scale the length and assign to this cell
+                scalar sLength = sumLength*growthFactor_;
+
+                lengthScale[cI] = sLength;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+// Read edge refinement options from the dictionary
+void lengthScaleEstimator::readRefinementOptions
+(
+    const dictionary& refineDict,
+    bool reRead,
+    bool mandatory
+)
+{
+    // Save old values
+    scalar oldRatioMax = ratioMax_;
+    scalar oldRatioMin = ratioMin_;
+    scalar oldGrowthFactor = growthFactor_;
+    scalar oldMinScale = minLengthScale_;
+    scalar oldMaxScale = maxLengthScale_;
+
+    ratioMax_ = readScalar(refineDict.lookup("bisectionRatio"));
+    ratioMin_ = readScalar(refineDict.lookup("collapseRatio"));
+    growthFactor_ = readScalar(refineDict.lookup("growthFactor"));
+
+    // Sanity check: Are ratios and growth-factor correctly specified?
+    if
+    (
+        ratioMin_ > ratioMax_ ||
+        ratioMin_ < VSMALL ||
+        ratioMax_ < VSMALL ||
+        growthFactor_ < 1.0
+    )
+    {
+        FatalErrorIn
+        (
+            "void lengthScaleEstimator::readRefinementOptions"
+            "(const dictionary&, bool, bool)"
+        )
+            << " Options are incorrectly specified." << nl
+            << " ratioMin: " << ratioMin_ << nl
+            << " ratioMax: " << ratioMax_ << nl
+            << " growthFactor: " << growthFactor_ << nl
+            << abort(FatalError);
+    }
+
+    if (refineDict.found("minLengthScale") || mandatory)
+    {
+        minLengthScale_ = readScalar(refineDict.lookup("minLengthScale"));
+    }
+
+    if (refineDict.found("maxLengthScale") || mandatory)
+    {
+        maxLengthScale_ = readScalar(refineDict.lookup("maxLengthScale"));
+    }
+
+    // Sanity check: Are min/max length scales correctly specified?
+    if (minLengthScale_ > maxLengthScale_)
+    {
+        FatalErrorIn
+        (
+            "void lengthScaleEstimator::readRefinementOptions"
+            "(const dictionary&, bool, bool)"
+        )
+            << " Length-scales are incorrectly specified." << nl
+            << " minLengthScale: " << minLengthScale_ << nl
+            << " maxLengthScale: " << maxLengthScale_ << nl
+            << abort(FatalError);
+    }
+
+    if (reRead)
+    {
+        // Check if values have changed, and report it.
+        if (mag(oldRatioMax - ratioMax_) > SMALL)
+        {
+            Info << "\tOld ratioMax: " << oldRatioMax << nl
+                 << "\tNew ratioMax: " << ratioMax_ << endl;
+        }
+
+        if (mag(oldRatioMin - ratioMin_) > SMALL)
+        {
+            Info << "\tOld ratioMin: " << oldRatioMin << nl
+                 << "\tNew ratioMin: " << ratioMin_ << endl;
+        }
+
+        if (mag(oldGrowthFactor - growthFactor_) > SMALL)
+        {
+            Info << "\tOld growthFactor: " << oldGrowthFactor << nl
+                 << "\tNew growthFactor: " << growthFactor_ << endl;
+        }
+
+        if (mag(oldMinScale - minLengthScale_) > SMALL)
+        {
+            Info << "\tOld minLengthScale: " << oldMinScale << nl
+                 << "\tNew minLengthScale: " << minLengthScale_ << endl;
+        }
+
+        if (mag(oldMaxScale - maxLengthScale_) > SMALL)
+        {
+            Info << "\tOld maxLengthScale: " << oldMaxScale << nl
+                 << "\tNew maxLengthScale: " << maxLengthScale_ << endl;
+        }
+    }
+
+    if (refineDict.found("fixedLengthScalePatches") || mandatory)
+    {
+        fixedPatches_ = refineDict.subDict("fixedLengthScalePatches");
+
+        // Ensure that patches are legitimate.
+        checkPatches(fixedPatches_.toc());
+    }
+
+    if (refineDict.found("freeLengthScalePatches") || mandatory)
+    {
+        freePatches_ = refineDict.subDict("freeLengthScalePatches");
+
+        // Ensure that patches are legitimate.
+        checkPatches(freePatches_.toc());
+
+        // Check if fixed and free patches are conflicting
+        if (fixedPatches_.size() && freePatches_.size())
+        {
+            wordList fixedPatchList = fixedPatches_.toc();
+            wordList freePatchList = freePatches_.toc();
+
+            forAll(fixedPatchList, wordI)
+            {
+                if (findIndex(freePatchList, fixedPatchList[wordI]) > -1)
+                {
+                    FatalErrorIn
+                    (
+                        "void lengthScaleEstimator::readRefinementOptions"
+                        "(const dictionary&, bool, bool)"
+                    )
+                        << " Conflicting fixed/free patches." << nl
+                        << " Patch: " << fixedPatchList[wordI] << nl
+                        << abort(FatalError);
+                }
+            }
+        }
+    }
+
+    if (refineDict.found("curvaturePatches") || mandatory)
+    {
+        curvaturePatches_ = refineDict.subDict("curvaturePatches");
+
+        // Ensure that patches are legitimate.
+        checkPatches(curvaturePatches_.toc());
+
+        curvatureDeviation_ =
+        (
+            readScalar(refineDict.lookup("curvatureDeviation"))
+        );
+
+        if (curvatureDeviation_ > 1.0 || curvatureDeviation_ < 0.0)
+        {
+            FatalErrorIn
+            (
+                "void lengthScaleEstimator::readRefinementOptions"
+                "(const dictionary&, bool, bool)"
+            )
+                << " Curvature deviation out of range [0..1]"
+                << abort(FatalError);
+        }
+    }
+
+    if (refineDict.found("proximityPatches") || mandatory)
+    {
+        proximityPatches_ =
+        (
+            refineDict.subDict("proximityPatches")
+        );
+
+        // Ensure that patches are legitimate.
+        checkPatches(proximityPatches_.toc());
+
+        // Check if a threshold for slicing has been specified.
+        if (refineDict.found("sliceThreshold") || mandatory)
+        {
+            sliceThreshold_ =
+            (
+                readScalar(refineDict.lookup("sliceThreshold"))
+            );
+
+            // Cap the threshold value
+            // sliceThreshold_ = Foam::max(sliceThreshold_, minLengthScale_);
+        }
+    }
+
+    // Check if edge-refinement is to be avoided on any patches
+    if (refineDict.found("noModificationPatches") || mandatory)
+    {
+        wordList noModPatches =
+        (
+            refineDict.subDict("noModificationPatches").toc()
+        );
+
+        // Ensure that patches are legitimate.
+        checkPatches(noModPatches);
+
+        noModPatchIDs_.setSize(noModPatches.size());
+
+        label indexI = 0;
+
+        forAll(noModPatches, wordI)
+        {
+            const word& patchName = noModPatches[wordI];
+
+            noModPatchIDs_[indexI++] =
+            (
+                mesh_.boundaryMesh().findPatchID(patchName)
+            );
+        }
+    }
+
+    // Check if refinement is to be performed based on a field-value
+    if (refineDict.found("fieldRefinement") || mandatory)
+    {
+        field_ = word(refineDict.lookup("fieldRefinement"));
+
+        // Lookup a specified length-scale
+        fieldLength_ = readScalar(refineDict.lookup("fieldLengthScale"));
+
+        lowerRefineLevel_ = readScalar(refineDict.lookup("lowerRefineLevel"));
+        upperRefineLevel_ = readScalar(refineDict.lookup("upperRefineLevel"));
+
+        // Sanity check: Are refinement levels correctly specified?
+        if (lowerRefineLevel_ > upperRefineLevel_)
+        {
+            FatalErrorIn
+            (
+                "void lengthScaleEstimator::readRefinementOptions"
+                "(const dictionary&, bool, bool)"
+            )
+                << " Refinement levels are incorrectly specified." << nl
+                << " lowerRefineLevel: " << lowerRefineLevel_ << nl
+                << " upperRefineLevel: " << upperRefineLevel_ << nl
+                << abort(FatalError);
+        }
+    }
+
+    // Check if a max refinement level has been specified
+    if (refineDict.found("maxRefineLevel") || mandatory)
+    {
+        maxRefineLevel_ = readLabel(refineDict.lookup("maxRefineLevel"));
+    }
+
+    // Update switch for mean-scale
+    if (refineDict.found("meanScale") || mandatory)
+    {
+        meanScale_ = readScalar(refineDict.lookup("meanScale"));
+    }
+}
+
+
+//- Set explicitly coupled patch information
+void lengthScaleEstimator::setCoupledPatches
+(
+    const dictionary& coupledPatches
+)
+{
+    label indexI = 0;
+
+    // Determine master and slave patches
+    wordList masterPatches(coupledPatches.size());
+    wordList slavePatches(coupledPatches.size());
+
+    forAllConstIter(dictionary, coupledPatches, dIter)
+    {
+        const dictionary& dictI = dIter().dict();
+
+        masterPatches[indexI] = word(dictI.lookup("master"));
+        slavePatches[indexI] = word(dictI.lookup("slave"));
+
+        indexI++;
+    }
+
+    // Ensure that patches are legitimate.
+    checkPatches(masterPatches);
+
+    // Check whether coupled patches are fixedPatches as well.
+    forAll(masterPatches, wordI)
+    {
+        word pName(masterPatches[wordI]);
+
+        if (fixedPatches_.found(pName))
+        {
+            // Add the slave patch to the list as well.
+            // If it already exists, over-ride the value.
+            fixedPatches_.add
+            (
+                slavePatches[wordI],
+                fixedPatches_[pName][0].scalarToken(),
+                true
+            );
+        }
+    }
+}
+
+
+//- Calculate the length scale field
+void lengthScaleEstimator::calculateLengthScale
+(
+    UList<scalar>& lengthScale
+)
+{
+    label level = 1, visitedCells = 0;
+    labelList cellLevels(mesh_.nCells(), 0);
+
+    // Check for allocation
+    if (lengthScale.size() != mesh_.nCells())
+    {
+        FatalErrorIn
+        (
+            "void lengthScaleEstimator::calculateLengthScale"
+            "(UList<scalar>& lengthScale)"
+        )
+            << " Field is incorrectly sized." << nl
+            << " Field size: " << lengthScale.size()
+            << " nCells: " << mesh_.nCells()
+            << abort(FatalError);
+    }
+
+    // HashSet to keep track of cells in each level
+    labelHashSet levelCells;
+
+    // Prepare for proximity-based refinement, if necessary
+    prepareProximityPatches();
+
+    // Obtain the cellCells addressing list
+    const labelList& own = mesh_.faceOwner();
+    const labelListList& cc = mesh_.cellCells();
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    forAll(boundary,patchI)
+    {
+        // Skip floating length-scale patches
+        if (isFreePatch(patchI))
+        {
+            continue;
+        }
+
+        const polyPatch& bdyPatch = boundary[patchI];
+
+        label pStart = bdyPatch.start();
+
+        forAll(bdyPatch,faceI)
+        {
+            label ownCell = own[pStart+faceI];
+
+            if (cellLevels[ownCell] != 0)
+            {
+                continue;
+            }
+
+            cellLevels[ownCell] = level;
+
+            lengthScale[ownCell] =
+            (
+                fixedLengthScale(pStart+faceI, patchI, true) * growthFactor_
+            );
+
+            levelCells.insert(ownCell);
+
+            visitedCells++;
+        }
+    }
+
+    // If a field has been specified, use that.
+    if (field_ != "none")
+    {
+        const volScalarField& vFld =
+        (
+            mesh_.objectRegistry::lookupObject<volScalarField>(field_)
+        );
+
+        const labelList& own = mesh_.faceOwner();
+        const labelList& nei = mesh_.faceNeighbour();
+
+        forAll(nei, faceI)
+        {
+            label ownCell = own[faceI], neiCell = nei[faceI];
+
+            scalar fAvg = 0.5 * (vFld[ownCell] + vFld[neiCell]);
+
+            if ((fAvg > lowerRefineLevel_) && (fAvg < upperRefineLevel_))
+            {
+                // Set the scale for cells on either side
+                if (!cellLevels[ownCell])
+                {
+                    cellLevels[ownCell] = level;
+                    lengthScale[ownCell] = fieldLength_;
+
+                    levelCells.insert(ownCell);
+
+                    visitedCells++;
+                }
+
+                if (!cellLevels[neiCell])
+                {
+                    cellLevels[neiCell] = level;
+                    lengthScale[neiCell] = fieldLength_;
+
+                    levelCells.insert(neiCell);
+
+                    visitedCells++;
+                }
+            }
+        }
+    }
+
+    bool doneWithSweeps = false;
+
+    // Perform multiple sweeps through the mesh...
+    while (!doneWithSweeps)
+    {
+        if (Pstream::parRun())
+        {
+            writeLengthScaleInfo(cellLevels, lengthScale);
+        }
+
+        // Loop through cells of the current level
+        labelList currLvlCells = levelCells.toc();
+        levelCells.clear();
+
+        // Loop through cells, and increment neighbour
+        // cells of the current level
+        forAll(currLvlCells,cellI)
+        {
+            // Obtain the cells neighbouring this one
+            const labelList& cList = cc[currLvlCells[cellI]];
+
+            forAll(cList, indexI)
+            {
+                label& ngbLevel = cellLevels[cList[indexI]];
+
+                if (ngbLevel == 0)
+                {
+                    ngbLevel = level + 1;
+
+                    // Compute the mean of the existing
+                    // neighbour length-scales
+                    const labelList& ncList = cc[cList[indexI]];
+                    scalar sumLength = 0.0;
+                    label nTouchedNgb = 0;
+
+                    forAll(ncList, indexJ)
+                    {
+                        label sLevel = cellLevels[ncList[indexJ]];
+
+                        if ((sLevel < ngbLevel) && (sLevel > 0))
+                        {
+                            sumLength += lengthScale[ncList[indexJ]];
+
+                            nTouchedNgb++;
+                        }
+                    }
+
+                    sumLength /= nTouchedNgb;
+
+                    // Scale the length and assign to this cell
+                    if (level < maxRefineLevel_)
+                    {
+                        sumLength *= growthFactor_;
+                    }
+                    else
+                    if (meanScale_ > 0.0)
+                    {
+                        // If a mean scale has been specified,
+                        // override the value
+                        sumLength = meanScale_;
+                    }
+
+                    lengthScale[cList[indexI]] = sumLength;
+
+                    levelCells.insert(cList[indexI]);
+
+                    visitedCells++;
+                }
+            }
+        }
+
+        if (Pstream::parRun())
+        {
+            readLengthScaleInfo
+            (
+                level,
+                visitedCells,
+                cellLevels,
+                lengthScale,
+                levelCells
+            );
+        }
+
+        if (debug > 2)
+        {
+            Pout << "Processed level: " << level << nl
+                 << " Visited: " << visitedCells
+                 << " out of " << mesh_.nCells() << endl;
+        }
+
+        // Move on to the next level
+        level++;
+
+        if (visitedCells >= mesh_.nCells())
+        {
+            doneWithSweeps = true;
+        }
+
+        // Wait for everyone to complete.
+        reduce(doneWithSweeps, andOp<bool>());
+    }
+
+    if (debug)
+    {
+        Info << "Max Length Scale: " << maxLengthScale_ << endl;
+        Info << "Length Scale sweeps: " << level << endl;
+    }
+
+    // Check if everything went okay
+    if (visitedCells != mesh_.nCells())
+    {
+        FatalErrorIn
+        (
+            "void lengthScaleEstimator::calculateLengthScale"
+            "(UList<scalar>& lengthScale)"
+        )
+            << " Algorithm did not visit every cell in the mesh."
+            << " Something's messed up." << nl
+            << " Visited cells: " << visitedCells
+            << " nCells: " << mesh_.nCells()
+            << abort(FatalError);
+    }
+
+    // Wait for transfers before continuing.
+    if (Pstream::parRun())
+    {
+        OPstream::waitRequests();
+        IPstream::waitRequests();
+    }
+}
+
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.H b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.H
new file mode 100644
index 000000000..0b9366e14
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimator.H
@@ -0,0 +1,278 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    lengthScaleEstimator
+
+Description
+    Utility class used to provide length-scale estimates at various
+    mesh locations. These estimates are based on specified boundary
+    conditions provided through dictionary entries.
+
+Author
+    Sandeep Menon
+    University of Massachusetts Amherst
+    All rights reserved
+
+SourceFiles
+    lengthScaleEstimator.C
+    lengthScaleEstimatorI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef lengthScaleEstimator_H
+#define lengthScaleEstimator_H
+
+#include "polyMesh.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class lengthScaleEstimator Declaration
+\*---------------------------------------------------------------------------*/
+
+class lengthScaleEstimator
+{
+    // Private data
+
+        //- Const reference to polyMesh
+        const polyMesh& mesh_;
+
+        //- Edge bisection/collapse criteria
+        scalar ratioMin_;
+        scalar ratioMax_;
+        scalar growthFactor_;
+        scalar minLengthScale_;
+        scalar maxLengthScale_;
+        scalar curvatureDeviation_;
+
+        //- Specific to proximity-based refinement
+        label spatialRes_;
+        boundBox proxBoundBox_;
+        labelListList proximityBins_;
+
+        //- Specific to mesh-slicing operations
+        scalar sliceThreshold_;
+        label sliceHoldOff_;
+        List<boundBox> sliceBoxes_;
+
+        // Buffers for parallel length-scale calculations
+        labelListList sendLblBuffer_;
+        labelListList recvLblBuffer_;
+        scalarListList sendSclBuffer_;
+        scalarListList recvSclBuffer_;
+
+        //- Sub-dictionary which specifies
+        //  fixed length-scales for patches
+        dictionary fixedPatches_;
+
+        //- Sub-dictionary which specifies
+        //  floating length-scales for patches
+        dictionary freePatches_;
+
+        //- Sub-dictionary which specifies
+        //  patches with curvature-based length-scale
+        dictionary curvaturePatches_;
+
+        //- Sub-dictionary which specifies
+        //  patches with proximity-based length-scale
+        dictionary proximityPatches_;
+
+        //- Patches for which edge-refinements
+        //  are to be avoided
+        labelList noModPatchIDs_;
+
+        //- Field-based refinement
+        word field_;
+        scalar fieldLength_;
+        scalar lowerRefineLevel_;
+        scalar upperRefineLevel_;
+
+        //- Specify limits for refinement criteria
+        scalar meanScale_;
+        label maxRefineLevel_;
+
+    // Private Member Functions
+
+        // Check for legitimacy of patches
+        void checkPatches(const wordList& patchList) const;
+
+        // Prepare for proximity-based refinement, if necessary
+        void prepareProximityPatches();
+
+        // Perform spatial hashing on a set of points
+        static void spatialHash
+        (
+            const pointField& pointLocations,
+            const labelList& pointIndices,
+            const boundBox& box,
+            const label resolution,
+            labelListList& bins
+        );
+
+        // Send length-scale info across processors
+        void writeLengthScaleInfo
+        (
+            const labelList& cellLevels,
+            const scalarList& lengthScale
+        );
+
+        // Receive length-scale info across processors
+        void readLengthScaleInfo
+        (
+            const label level,
+            label& visitedCells,
+            labelList& cellLevels,
+            UList<scalar>& lengthScale,
+            labelHashSet& levelCells
+        ) const;
+
+public:
+
+    // Declare the name of the class and its debug switch
+        TypeName("lengthScaleEstimator");
+
+    // Constructors
+
+        //- Construct from polyMesh and dictionary
+        explicit lengthScaleEstimator
+        (
+            const polyMesh& mesh
+        );
+
+    // Destructor
+
+        virtual ~lengthScaleEstimator();
+
+    // Member Functions
+
+        //- Read edge refinement options from the dictionary
+        void readRefinementOptions
+        (
+            const dictionary& refineDict,
+            bool reRead = false,
+            bool mandatory = false
+        );
+
+        //- Set explicitly coupled patch information
+        void setCoupledPatches
+        (
+            const dictionary& coupledPatches
+        );
+
+        //- Calculate the length scale field
+        void calculateLengthScale(UList<scalar>& lengthScale);
+
+        //- Return refinement criteria
+        inline scalar ratioMin() const;
+        inline scalar ratioMax() const;
+        inline scalar growthFactor() const;
+
+        //- Limit length scale for surface-edges
+        inline void limitScale(scalar& scale) const;
+
+        //- Check if a particular patch is free-floating
+        //  (i.e., gets its length-scale from the interior)
+        inline bool isFreePatch(const label pIndex) const;
+
+        //- Check if a particular patch is flagged
+        //  for proximity-based refinement
+        inline bool isProximityPatch(const label pIndex) const;
+
+        //- Check if a particular patch is flagged
+        //  for curvature-based refinement
+        inline bool isCurvaturePatch(const label pIndex) const;
+
+        //- Return reference curvature deviation
+        inline scalar curvatureDeviation() const
+        {
+            return curvatureDeviation_;
+        }
+
+        //- Check whether a particular point is too close
+        //  to a previous mesh slice location
+        inline bool checkOldSlices(const vector& gCentre) const;
+
+        //- Add a boundBox to the existing set of sliceBoxes
+        inline void appendBox(const boundBox& bBox);
+
+        //- Clear the list of sliceBoxes
+        inline void clearBoxes();
+
+        //- Set an initial hold-off value
+        inline void setHoldOff(const label hVal)
+        {
+            sliceHoldOff_ = hVal;
+        }
+
+        //- Return the current holdOff value
+        inline label holdOff() const
+        {
+            return sliceHoldOff_;
+        }
+
+        //- Decrement the current holdOff value
+        inline void decrementHoldOff()
+        {
+            sliceHoldOff_--;
+        }
+
+        //- Check whether a particular patch permits refinement
+        inline bool checkRefinementPatch
+        (
+            const label pIndex
+        ) const;
+
+        //- Return the appropriate length-scale for boundary face
+        inline scalar fixedLengthScale
+        (
+            const label fIndex,
+            const label pIndex,
+            bool usePolyMesh = false
+        ) const;
+
+        //- Test for proximity to patch faces
+        inline bool testProximity
+        (
+            const vector& gCentre,
+            const vector& gNormal,
+            const scalar testStep,
+            label& proxFace,
+            scalar& proxDistance
+        ) const;
+};
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "lengthScaleEstimatorI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
diff --git a/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimatorI.H b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimatorI.H
new file mode 100644
index 000000000..8b0ef6ef4
--- /dev/null
+++ b/src/dynamicMesh/dynamicFvMesh/lengthScaleEstimator/lengthScaleEstimatorI.H
@@ -0,0 +1,329 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright held by original author
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline scalar lengthScaleEstimator::ratioMin() const
+{
+    return ratioMin_;
+}
+
+
+inline scalar lengthScaleEstimator::ratioMax() const
+{
+    return ratioMax_;
+}
+
+
+inline scalar lengthScaleEstimator::growthFactor() const
+{
+    return growthFactor_;
+}
+
+
+//- Limit length scale for surface-edges
+inline void lengthScaleEstimator::limitScale(scalar& scale) const
+{
+    // Need to account for multiplication by ratioMin / ratioMax as well
+    scale = Foam::max(scale, minLengthScale_ / ratioMin_);
+    scale = Foam::min(scale, maxLengthScale_ / ratioMax_);
+}
+
+
+//- Check if a particular patch is free-floating
+//  (i.e., gets its length-scale from the interior)
+inline bool lengthScaleEstimator::isFreePatch
+(
+    const label pIndex
+) const
+{
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    if (freePatches_.found(boundary[pIndex].name()))
+    {
+        return true;
+    }
+
+    // Certain boundary types are also considered floating
+    const word& pType = boundary[pIndex].type();
+
+    if
+    (
+        (pType == "processor") ||
+        (pType == "cyclic") ||
+        (pType == "wedge") ||
+        (pType == "empty") ||
+        (pType == "symmetryPlane")
+    )
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+//- Check if a particular patch is flagged
+//  for proximity-based refinement
+inline bool lengthScaleEstimator::isProximityPatch
+(
+    const label pIndex
+) const
+{
+    if (proximityPatches_.found(mesh_.boundaryMesh()[pIndex].name()))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+//- Check if a particular patch is flagged
+//  for curvature-based refinement
+inline bool lengthScaleEstimator::isCurvaturePatch
+(
+    const label pIndex
+) const
+{
+    if (curvaturePatches_.found(mesh_.boundaryMesh()[pIndex].name()))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+//- Check whether a particular point is too close
+//  to a previous mesh slice location
+inline bool lengthScaleEstimator::checkOldSlices
+(
+    const vector& gCentre
+) const
+{
+    forAll(sliceBoxes_, boxI)
+    {
+        if (sliceBoxes_[boxI].contains(gCentre))
+        {
+            // Too close to another slice-point. Bail out.
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+//- Add a boundBox to the existing set of sliceBoxes
+inline void lengthScaleEstimator::appendBox
+(
+    const boundBox& bBox
+)
+{
+    label currentSize = sliceBoxes_.size();
+    sliceBoxes_.setSize(currentSize + 1);
+    sliceBoxes_[currentSize] = bBox;
+}
+
+
+//- Clear the list of sliceBoxes
+inline void lengthScaleEstimator::clearBoxes()
+{
+    sliceBoxes_.clear();
+}
+
+
+//- Check whether a particular patch permits refinement
+//  - Return true if not permitted
+inline bool lengthScaleEstimator::checkRefinementPatch
+(
+    const label pIndex
+) const
+{
+    if (pIndex < 0)
+    {
+        return false;
+    }
+
+    if (findIndex(noModPatchIDs_, pIndex) > -1)
+    {
+        return true;
+    }
+
+    // Refinement is allowed
+    return false;
+}
+
+
+// Return the fixed length-scale value for a boundary face
+inline scalar lengthScaleEstimator::fixedLengthScale
+(
+    const label fIndex,
+    const label pIndex,
+    bool usePolyMesh
+) const
+{
+    scalar scale = 0.0;
+
+    const polyBoundaryMesh& boundary = mesh_.boundaryMesh();
+
+    // Check fixed length-scale patches
+    // If the value is negative, average face length-scales.
+    if (fixedPatches_.found(boundary[pIndex].name()))
+    {
+        scalar dictValue =
+        (
+            fixedPatches_[boundary[pIndex].name()][0].scalarToken()
+        );
+
+        if (dictValue > 0.0)
+        {
+            return dictValue;
+        }
+    }
+
+    // Approximate a length-scale from face area
+    if (usePolyMesh)
+    {
+        scale = Foam::sqrt(2.0 * mag(mesh_.faceAreas()[fIndex]));
+    }
+
+    return scale;
+}
+
+
+// Test an edge / face for proximity with other faces on proximity patches
+// and return the scalar distance to an oppositely-oriented face.
+inline bool lengthScaleEstimator::testProximity
+(
+    const vector& gCentre,
+    const vector& gNormal,
+    const scalar testStep,
+    label& proxFace,
+    scalar& proxDistance
+) const
+{
+    // Reset input
+    proxDistance = GREAT;
+
+    DynamicList<label> posIndices(20);
+    scalar minDeviation = -0.9;
+    label nD = spatialRes_, binSize = proximityBins_.size();
+
+    // Obtain min/max extents
+    const point& bMin = proxBoundBox_.min();
+    const point& bMax = proxBoundBox_.max();
+
+    // Extend bounding-box dimensions a bit to avoid edge-effects.
+    scalar ext = 0.02*(mag(bMax - bMin));
+
+    // Define an inverse grid-cell size.
+    scalar xL = nD/(bMax.x() - bMin.x() + ext);
+    scalar yL = nD/(bMax.y() - bMin.y() + ext);
+    scalar zL = nD/(bMax.z() - bMin.z() + ext);
+
+    // Reset the proximity face
+    proxFace = -1;
+
+    // Now take multiple steps in both normal directions,
+    // and add to the list of boxes to be checked.
+    for (scalar dir = -1.0; dir < 2.0; dir += 2.0)
+    {
+        for (scalar step = 0.0; step < 5.0*testStep; step += testStep)
+        {
+            // Hash the point-location
+            point p = (gCentre + (dir*step*gNormal)) - bMin;
+
+            label i = label(mag(::floor(p.x()*xL)));
+            label j = label(mag(::floor(p.y()*yL)));
+            label k = label(mag(::floor(p.z()*zL)));
+
+            label pos = mag(((k*nD*nD)+(j*nD)+i) % binSize);
+
+            if (findIndex(posIndices, pos) == -1)
+            {
+                posIndices.append(pos);
+            }
+        }
+    }
+
+    // Obtain old-mesh face geometry for reference.
+    const vectorField& faceAreas = mesh_.faceAreas();
+    const vectorField& faceCentres = mesh_.faceCentres();
+
+    forAll(posIndices, indexI)
+    {
+        const labelList& posBin = proximityBins_[posIndices[indexI]];
+
+        forAll(posBin, faceI)
+        {
+            // Step 1: Measure the distance to the face.
+            vector rFace = (faceCentres[posBin[faceI]] - gCentre);
+
+            scalar distance = mag(rFace);
+
+            // Step 2: Check if this face is oriented away from face / edge.
+            const vector& fNormal = faceAreas[posBin[faceI]];
+
+            scalar deviation = (gNormal & (fNormal/(mag(fNormal) + VSMALL)));
+
+            if
+            (
+                (deviation < minDeviation) &&
+                (distance < proxDistance)
+            )
+            {
+                // Update statistics
+                proxFace = posBin[faceI];
+                proxDistance = distance;
+                // minDeviation = deviation;
+            }
+        }
+    }
+
+    // Check for fall below threshold
+    if ((proxFace != -1) && (proxDistance < sliceThreshold_))
+    {
+        return true;
+    }
+
+    // Does not fall below threshold
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/dynamicMesh/topoChangerFvMesh/Make/options b/src/dynamicMesh/topoChangerFvMesh/Make/options
index 3fd5dc1e5..5e46ce41d 100644
--- a/src/dynamicMesh/topoChangerFvMesh/Make/options
+++ b/src/dynamicMesh/topoChangerFvMesh/Make/options
@@ -3,7 +3,7 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicMesh/dynamicFvMesh/lnInclude \
     -I$(LIB_SRC)/dynamicMesh/dynamicMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/tetDecompositionMotionSolver/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/meshMotion/tetDecompositionMotionSolver/lnInclude \
     -I$(LIB_SRC)/tetDecompositionFiniteElement/lnInclude \
     $(WM_DECOMP_INC)